diff options
Diffstat (limited to '1.4.0/dom/src/1.4/dom')
173 files changed, 52074 insertions, 0 deletions
diff --git a/1.4.0/dom/src/1.4/dom/domAccessor.cpp b/1.4.0/dom/src/1.4/dom/domAccessor.cpp new file mode 100644 index 0000000..2c30df8 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domAccessor.cpp @@ -0,0 +1,106 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domAccessor.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domAccessor::create(DAE& dae) +{ + domAccessorRef ref = new domAccessor(dae); + return ref; +} + + +daeMetaElement * +domAccessor::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "accessor" ); + meta->registerClass(domAccessor::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "param" ); + mea->setOffset( daeOffsetOf(domAccessor,elemParam_array) ); + mea->setElementType( domParam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: count + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "count" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domAccessor , attrCount )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: offset + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "offset" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domAccessor , attrOffset )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + + meta->appendAttribute(ma); + } + + // Add attribute: source + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "source" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domAccessor , attrSource )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: stride + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "stride" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domAccessor , attrStride )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAccessor)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domAnimation.cpp b/1.4.0/dom/src/1.4/dom/domAnimation.cpp new file mode 100644 index 0000000..b0bfcc7 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domAnimation.cpp @@ -0,0 +1,175 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domAnimation.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domAnimation::create(DAE& dae) +{ + domAnimationRef ref = new domAnimation(dae); + return ref; +} + + +daeMetaElement * +domAnimation::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "animation" ); + meta->registerClass(domAnimation::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domAnimation,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, -1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domAnimation,elemSource_array) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 1, 1, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, -1 ); + mea->setName( "sampler" ); + mea->setOffset( daeOffsetOf(domAnimation,elemSampler_array) ); + mea->setElementType( domSampler::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "channel" ); + mea->setOffset( daeOffsetOf(domAnimation,elemChannel_array) ); + mea->setElementType( domChannel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "animation" ); + mea->setOffset( daeOffsetOf(domAnimation,elemAnimation_array) ); + mea->setElementType( domAnimation::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 1, -1 ); + mea->setName( "animation" ); + mea->setOffset( daeOffsetOf(domAnimation,elemAnimation_array) ); + mea->setElementType( domAnimation::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 1 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm = new daeMetaSequence( meta, cm, 2, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, -1 ); + mea->setName( "sampler" ); + mea->setOffset( daeOffsetOf(domAnimation,elemSampler_array) ); + mea->setElementType( domSampler::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "channel" ); + mea->setOffset( daeOffsetOf(domAnimation,elemChannel_array) ); + mea->setElementType( domChannel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "animation" ); + mea->setOffset( daeOffsetOf(domAnimation,elemAnimation_array) ); + mea->setElementType( domAnimation::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 5, 1, -1 ); + mea->setName( "animation" ); + mea->setOffset( daeOffsetOf(domAnimation,elemAnimation_array) ); + mea->setElementType( domAnimation::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 4 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domAnimation,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domAnimation,_contents)); + meta->addContentsOrder(daeOffsetOf(domAnimation,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domAnimation,_CMData), 2); + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domAnimation , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domAnimation , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAnimation)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domAnimation_clip.cpp b/1.4.0/dom/src/1.4/dom/domAnimation_clip.cpp new file mode 100644 index 0000000..ebfbfa9 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domAnimation_clip.cpp @@ -0,0 +1,116 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domAnimation_clip.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domAnimation_clip::create(DAE& dae) +{ + domAnimation_clipRef ref = new domAnimation_clip(dae); + return ref; +} + + +daeMetaElement * +domAnimation_clip::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "animation_clip" ); + meta->registerClass(domAnimation_clip::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domAnimation_clip,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "instance_animation" ); + mea->setOffset( daeOffsetOf(domAnimation_clip,elemInstance_animation_array) ); + mea->setElementType( domInstanceWithExtra::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domAnimation_clip,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domAnimation_clip , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domAnimation_clip , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: start + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "start" ); + ma->setType( dae.getAtomicTypes().get("xsDouble")); + ma->setOffset( daeOffsetOf( domAnimation_clip , attrStart )); + ma->setContainer( meta ); + ma->setDefaultString( "0.0"); + + meta->appendAttribute(ma); + } + + // Add attribute: end + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "end" ); + ma->setType( dae.getAtomicTypes().get("xsDouble")); + ma->setOffset( daeOffsetOf( domAnimation_clip , attrEnd )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAnimation_clip)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domAny.cpp b/1.4.0/dom/src/1.4/dom/domAny.cpp new file mode 100644 index 0000000..231dc33 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domAny.cpp @@ -0,0 +1,109 @@ +/* + * Copyright 2006 Sony Computer Entertainment Inc. + * + * Licensed under the MIT Open Source License, for details please see license.txt or the website + * http://www.opensource.org/licenses/mit-license.php + * + */ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domAny.h> +#include <dae/daeMetaAttribute.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> +#include <dae/daeErrorHandler.h> + + +namespace ColladaDOM141 { +daeElementRef +domAny::create(DAE& dae) +{ + domAnyRef ref = new domAny; + return ref; +} + + +daeMetaElement * +domAny::registerElement(DAE& dae) +{ + daeMetaElement *_Meta = new daeMetaElement(dae); + _Meta->setName( "any" ); + _Meta->registerClass(domAny::create); + _Meta->setIsInnerClass( true ); + + daeMetaCMPolicy *cm = NULL; + cm = new daeMetaSequence( _Meta, cm, 0, 1, 1 ); + + cm = new daeMetaAny( _Meta, cm, 0, 0, -1 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 0 ); + _Meta->setCMRoot( cm ); + _Meta->setAllowsAny( true ); + + _Meta->addContents(daeOffsetOf(domAny,_contents)); + _Meta->addContentsOrder(daeOffsetOf(domAny,_contentsOrder)); + + //VALUE + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domAny, _value )); + ma->setContainer( _Meta ); + _Meta->appendAttribute(ma); + } + + _Meta->setElementSize(sizeof(domAny)); + _Meta->validate(); + + return _Meta; +} + +domAny::~domAny() { + // domAny objects own their corresponding daeMetaElement + delete _meta; +} + +// Implementation of daeMetaAttribute that understands how domAny works +class domAnyAttribute : public daeMetaAttribute { +public: + virtual daeChar* getWritableMemory(daeElement* e) { + return (daeChar*)&((domAny*)e)->attrs[_offset]; + } +}; + +daeBool domAny::setAttribute(daeString attrName, daeString attrValue) { + if (_meta == NULL) + return false; + + //if the attribute already exists set it. + if (daeElement::setAttribute(attrName, attrValue)) + return true; + + //else register it and then set it. + attrs.append(""); + daeMetaAttribute *ma = new domAnyAttribute; + ma->setName( attrName ); + ma->setType( getDAE()->getAtomicTypes().get("xsString")); + ma->setOffset((daeInt)attrs.getCount()-1); + ma->setContainer( _meta ); + if (ma->getType()) { + _meta->appendAttribute(ma); + _validAttributeArray.append( true ); + ma->stringToMemory(this, attrValue); + return true; + } + + delete ma; + return false; +} + + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domAsset.cpp b/1.4.0/dom/src/1.4/dom/domAsset.cpp new file mode 100644 index 0000000..7e1f4c2 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domAsset.cpp @@ -0,0 +1,653 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domAsset.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domAsset::create(DAE& dae) +{ + domAssetRef ref = new domAsset(dae); + return ref; +} + + +daeMetaElement * +domAsset::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "asset" ); + meta->registerClass(domAsset::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "contributor" ); + mea->setOffset( daeOffsetOf(domAsset,elemContributor_array) ); + mea->setElementType( domAsset::domContributor::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "created" ); + mea->setOffset( daeOffsetOf(domAsset,elemCreated) ); + mea->setElementType( domAsset::domCreated::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "keywords" ); + mea->setOffset( daeOffsetOf(domAsset,elemKeywords) ); + mea->setElementType( domAsset::domKeywords::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 1, 1 ); + mea->setName( "modified" ); + mea->setOffset( daeOffsetOf(domAsset,elemModified) ); + mea->setElementType( domAsset::domModified::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "revision" ); + mea->setOffset( daeOffsetOf(domAsset,elemRevision) ); + mea->setElementType( domAsset::domRevision::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "subject" ); + mea->setOffset( daeOffsetOf(domAsset,elemSubject) ); + mea->setElementType( domAsset::domSubject::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "title" ); + mea->setOffset( daeOffsetOf(domAsset,elemTitle) ); + mea->setElementType( domAsset::domTitle::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "unit" ); + mea->setOffset( daeOffsetOf(domAsset,elemUnit) ); + mea->setElementType( domAsset::domUnit::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 8, 0, 1 ); + mea->setName( "up_axis" ); + mea->setOffset( daeOffsetOf(domAsset,elemUp_axis) ); + mea->setElementType( domAsset::domUp_axis::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 8 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domAsset)); + meta->validate(); + + return meta; +} + +daeElementRef +domAsset::domContributor::create(DAE& dae) +{ + domAsset::domContributorRef ref = new domAsset::domContributor(dae); + return ref; +} + + +daeMetaElement * +domAsset::domContributor::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "contributor" ); + meta->registerClass(domAsset::domContributor::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "author" ); + mea->setOffset( daeOffsetOf(domAsset::domContributor,elemAuthor) ); + mea->setElementType( domAsset::domContributor::domAuthor::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "authoring_tool" ); + mea->setOffset( daeOffsetOf(domAsset::domContributor,elemAuthoring_tool) ); + mea->setElementType( domAsset::domContributor::domAuthoring_tool::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "comments" ); + mea->setOffset( daeOffsetOf(domAsset::domContributor,elemComments) ); + mea->setElementType( domAsset::domContributor::domComments::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "copyright" ); + mea->setOffset( daeOffsetOf(domAsset::domContributor,elemCopyright) ); + mea->setElementType( domAsset::domContributor::domCopyright::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "source_data" ); + mea->setOffset( daeOffsetOf(domAsset::domContributor,elemSource_data) ); + mea->setElementType( domAsset::domContributor::domSource_data::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 4 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domAsset::domContributor)); + meta->validate(); + + return meta; +} + +daeElementRef +domAsset::domContributor::domAuthor::create(DAE& dae) +{ + domAsset::domContributor::domAuthorRef ref = new domAsset::domContributor::domAuthor(dae); + return ref; +} + + +daeMetaElement * +domAsset::domContributor::domAuthor::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "author" ); + meta->registerClass(domAsset::domContributor::domAuthor::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domAsset::domContributor::domAuthor , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAsset::domContributor::domAuthor)); + meta->validate(); + + return meta; +} + +daeElementRef +domAsset::domContributor::domAuthoring_tool::create(DAE& dae) +{ + domAsset::domContributor::domAuthoring_toolRef ref = new domAsset::domContributor::domAuthoring_tool(dae); + return ref; +} + + +daeMetaElement * +domAsset::domContributor::domAuthoring_tool::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "authoring_tool" ); + meta->registerClass(domAsset::domContributor::domAuthoring_tool::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domAsset::domContributor::domAuthoring_tool , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAsset::domContributor::domAuthoring_tool)); + meta->validate(); + + return meta; +} + +daeElementRef +domAsset::domContributor::domComments::create(DAE& dae) +{ + domAsset::domContributor::domCommentsRef ref = new domAsset::domContributor::domComments(dae); + return ref; +} + + +daeMetaElement * +domAsset::domContributor::domComments::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "comments" ); + meta->registerClass(domAsset::domContributor::domComments::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domAsset::domContributor::domComments , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAsset::domContributor::domComments)); + meta->validate(); + + return meta; +} + +daeElementRef +domAsset::domContributor::domCopyright::create(DAE& dae) +{ + domAsset::domContributor::domCopyrightRef ref = new domAsset::domContributor::domCopyright(dae); + return ref; +} + + +daeMetaElement * +domAsset::domContributor::domCopyright::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "copyright" ); + meta->registerClass(domAsset::domContributor::domCopyright::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domAsset::domContributor::domCopyright , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAsset::domContributor::domCopyright)); + meta->validate(); + + return meta; +} + +daeElementRef +domAsset::domContributor::domSource_data::create(DAE& dae) +{ + domAsset::domContributor::domSource_dataRef ref = new domAsset::domContributor::domSource_data(dae); + return ref; +} + + +daeMetaElement * +domAsset::domContributor::domSource_data::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "source_data" ); + meta->registerClass(domAsset::domContributor::domSource_data::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domAsset::domContributor::domSource_data , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAsset::domContributor::domSource_data)); + meta->validate(); + + return meta; +} + +daeElementRef +domAsset::domCreated::create(DAE& dae) +{ + domAsset::domCreatedRef ref = new domAsset::domCreated(dae); + return ref; +} + + +daeMetaElement * +domAsset::domCreated::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "created" ); + meta->registerClass(domAsset::domCreated::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsDateTime")); + ma->setOffset( daeOffsetOf( domAsset::domCreated , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAsset::domCreated)); + meta->validate(); + + return meta; +} + +daeElementRef +domAsset::domKeywords::create(DAE& dae) +{ + domAsset::domKeywordsRef ref = new domAsset::domKeywords(dae); + return ref; +} + + +daeMetaElement * +domAsset::domKeywords::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "keywords" ); + meta->registerClass(domAsset::domKeywords::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domAsset::domKeywords , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAsset::domKeywords)); + meta->validate(); + + return meta; +} + +daeElementRef +domAsset::domModified::create(DAE& dae) +{ + domAsset::domModifiedRef ref = new domAsset::domModified(dae); + return ref; +} + + +daeMetaElement * +domAsset::domModified::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "modified" ); + meta->registerClass(domAsset::domModified::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsDateTime")); + ma->setOffset( daeOffsetOf( domAsset::domModified , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAsset::domModified)); + meta->validate(); + + return meta; +} + +daeElementRef +domAsset::domRevision::create(DAE& dae) +{ + domAsset::domRevisionRef ref = new domAsset::domRevision(dae); + return ref; +} + + +daeMetaElement * +domAsset::domRevision::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "revision" ); + meta->registerClass(domAsset::domRevision::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domAsset::domRevision , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAsset::domRevision)); + meta->validate(); + + return meta; +} + +daeElementRef +domAsset::domSubject::create(DAE& dae) +{ + domAsset::domSubjectRef ref = new domAsset::domSubject(dae); + return ref; +} + + +daeMetaElement * +domAsset::domSubject::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "subject" ); + meta->registerClass(domAsset::domSubject::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domAsset::domSubject , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAsset::domSubject)); + meta->validate(); + + return meta; +} + +daeElementRef +domAsset::domTitle::create(DAE& dae) +{ + domAsset::domTitleRef ref = new domAsset::domTitle(dae); + return ref; +} + + +daeMetaElement * +domAsset::domTitle::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "title" ); + meta->registerClass(domAsset::domTitle::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domAsset::domTitle , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAsset::domTitle)); + meta->validate(); + + return meta; +} + +daeElementRef +domAsset::domUnit::create(DAE& dae) +{ + domAsset::domUnitRef ref = new domAsset::domUnit(dae); + return ref; +} + + +daeMetaElement * +domAsset::domUnit::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "unit" ); + meta->registerClass(domAsset::domUnit::create); + + meta->setIsInnerClass( true ); + + // Add attribute: meter + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "meter" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domAsset::domUnit , attrMeter )); + ma->setContainer( meta ); + ma->setDefaultString( "1.0"); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNMTOKEN")); + ma->setOffset( daeOffsetOf( domAsset::domUnit , attrName )); + ma->setContainer( meta ); + ma->setDefaultString( "meter"); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAsset::domUnit)); + meta->validate(); + + return meta; +} + +daeElementRef +domAsset::domUp_axis::create(DAE& dae) +{ + domAsset::domUp_axisRef ref = new domAsset::domUp_axis(dae); + return ref; +} + + +daeMetaElement * +domAsset::domUp_axis::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "up_axis" ); + meta->registerClass(domAsset::domUp_axis::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("UpAxisType")); + ma->setOffset( daeOffsetOf( domAsset::domUp_axis , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domAsset::domUp_axis)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domBind_material.cpp b/1.4.0/dom/src/1.4/dom/domBind_material.cpp new file mode 100644 index 0000000..9d1936b --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domBind_material.cpp @@ -0,0 +1,116 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domBind_material.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domBind_material::create(DAE& dae) +{ + domBind_materialRef ref = new domBind_material(dae); + return ref; +} + + +daeMetaElement * +domBind_material::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bind_material" ); + meta->registerClass(domBind_material::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "param" ); + mea->setOffset( daeOffsetOf(domBind_material,elemParam_array) ); + mea->setElementType( domParam::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "technique_common" ); + mea->setOffset( daeOffsetOf(domBind_material,elemTechnique_common) ); + mea->setElementType( domBind_material::domTechnique_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domBind_material,elemTechnique_array) ); + mea->setElementType( domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domBind_material,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domBind_material)); + meta->validate(); + + return meta; +} + +daeElementRef +domBind_material::domTechnique_common::create(DAE& dae) +{ + domBind_material::domTechnique_commonRef ref = new domBind_material::domTechnique_common(dae); + return ref; +} + + +daeMetaElement * +domBind_material::domTechnique_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "technique_common" ); + meta->registerClass(domBind_material::domTechnique_common::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, -1 ); + mea->setName( "instance_material" ); + mea->setOffset( daeOffsetOf(domBind_material::domTechnique_common,elemInstance_material_array) ); + mea->setElementType( domInstance_material::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domBind_material::domTechnique_common)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domBool_array.cpp b/1.4.0/dom/src/1.4/dom/domBool_array.cpp new file mode 100644 index 0000000..bb35cd9 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domBool_array.cpp @@ -0,0 +1,90 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domBool_array.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domBool_array::create(DAE& dae) +{ + domBool_arrayRef ref = new domBool_array(dae); + return ref; +} + + +daeMetaElement * +domBool_array::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool_array" ); + meta->registerClass(domBool_array::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("ListOfBools")); + ma->setOffset( daeOffsetOf( domBool_array , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domBool_array , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domBool_array , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: count + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "count" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domBool_array , attrCount )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domBool_array)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domBox.cpp b/1.4.0/dom/src/1.4/dom/domBox.cpp new file mode 100644 index 0000000..4a0f68d --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domBox.cpp @@ -0,0 +1,101 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domBox.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domBox::create(DAE& dae) +{ + domBoxRef ref = new domBox(dae); + return ref; +} + + +daeMetaElement * +domBox::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "box" ); + meta->registerClass(domBox::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half_extents" ); + mea->setOffset( daeOffsetOf(domBox,elemHalf_extents) ); + mea->setElementType( domBox::domHalf_extents::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domBox,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domBox)); + meta->validate(); + + return meta; +} + +daeElementRef +domBox::domHalf_extents::create(DAE& dae) +{ + domBox::domHalf_extentsRef ref = new domBox::domHalf_extents(dae); + return ref; +} + + +daeMetaElement * +domBox::domHalf_extents::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half_extents" ); + meta->registerClass(domBox::domHalf_extents::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domBox::domHalf_extents , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domBox::domHalf_extents)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCOLLADA.cpp b/1.4.0/dom/src/1.4/dom/domCOLLADA.cpp new file mode 100644 index 0000000..95ce285 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCOLLADA.cpp @@ -0,0 +1,261 @@ +/* + * Copyright 2006 Sony Computer Entertainment Inc. + * + * Licensed under the MIT Open Source License, for details please see license.txt or the website + * http://www.opensource.org/licenses/mit-license.php + * + */ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCOLLADA.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + +namespace ColladaDOM141 { +extern daeString COLLADA_VERSION; +extern daeString COLLADA_NAMESPACE; + +daeElementRef +domCOLLADA::create(DAE& dae) +{ + domCOLLADARef ref = new domCOLLADA(dae); + ref->_meta = dae.getMeta(domCOLLADA::ID()); + ref->setAttribute("version", COLLADA_VERSION ); + ref->setAttribute("xmlns", COLLADA_NAMESPACE ); + ref->_meta = NULL; + return ref; +} + + +daeMetaElement * +domCOLLADA::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "COLLADA" ); + meta->registerClass(domCOLLADA::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "library_animations" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemLibrary_animations_array) ); + mea->setElementType( domLibrary_animations::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "library_animation_clips" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemLibrary_animation_clips_array) ); + mea->setElementType( domLibrary_animation_clips::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "library_cameras" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemLibrary_cameras_array) ); + mea->setElementType( domLibrary_cameras::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "library_controllers" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemLibrary_controllers_array) ); + mea->setElementType( domLibrary_controllers::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "library_geometries" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemLibrary_geometries_array) ); + mea->setElementType( domLibrary_geometries::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "library_effects" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemLibrary_effects_array) ); + mea->setElementType( domLibrary_effects::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "library_force_fields" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemLibrary_force_fields_array) ); + mea->setElementType( domLibrary_force_fields::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "library_images" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemLibrary_images_array) ); + mea->setElementType( domLibrary_images::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "library_lights" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemLibrary_lights_array) ); + mea->setElementType( domLibrary_lights::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "library_materials" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemLibrary_materials_array) ); + mea->setElementType( domLibrary_materials::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "library_nodes" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemLibrary_nodes_array) ); + mea->setElementType( domLibrary_nodes::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "library_physics_materials" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemLibrary_physics_materials_array) ); + mea->setElementType( domLibrary_physics_materials::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "library_physics_models" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemLibrary_physics_models_array) ); + mea->setElementType( domLibrary_physics_models::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "library_physics_scenes" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemLibrary_physics_scenes_array) ); + mea->setElementType( domLibrary_physics_scenes::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "library_visual_scenes" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemLibrary_visual_scenes_array) ); + mea->setElementType( domLibrary_visual_scenes::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementAttribute( meta, cm, 3002, 0, 1 ); + mea->setName( "scene" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemScene) ); + mea->setElementType( domCOLLADA::domScene::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3003, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domCOLLADA,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3003 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCOLLADA,_contents)); + meta->addContentsOrder(daeOffsetOf(domCOLLADA,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCOLLADA,_CMData), 1); // Add attribute: xmlns + { + daeMetaAttribute* ma = new daeMetaAttribute; + ma->setName( "xmlns" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domCOLLADA, attrXmlns )); + ma->setContainer( meta ); + //ma->setIsRequired( true ); + meta->appendAttribute(ma); + } + + // Add attribute: version + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "version" ); + ma->setType( dae.getAtomicTypes().get("VersionType")); + ma->setOffset( daeOffsetOf( domCOLLADA, attrVersion )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: xml_base + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "xml_base" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domCOLLADA, attrXml_base )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCOLLADA)); + meta->validate(); + + return meta; +} + +daeElementRef +domCOLLADA::domScene::create(DAE& dae) +{ + domCOLLADA::domSceneRef ref = new domCOLLADA::domScene(dae); + return ref; +} + + +daeMetaElement * +domCOLLADA::domScene::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "scene" ); + meta->registerClass(domCOLLADA::domScene::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "instance_physics_scene" ); + mea->setOffset( daeOffsetOf(domCOLLADA::domScene,elemInstance_physics_scene_array) ); + mea->setElementType( domInstanceWithExtra::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "instance_visual_scene" ); + mea->setOffset( daeOffsetOf(domCOLLADA::domScene,elemInstance_visual_scene) ); + mea->setElementType( domInstanceWithExtra::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domCOLLADA::domScene,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domCOLLADA::domScene)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCamera.cpp b/1.4.0/dom/src/1.4/dom/domCamera.cpp new file mode 100644 index 0000000..fc2d3b0 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCamera.cpp @@ -0,0 +1,450 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCamera.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCamera::create(DAE& dae) +{ + domCameraRef ref = new domCamera(dae); + return ref; +} + + +daeMetaElement * +domCamera::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "camera" ); + meta->registerClass(domCamera::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domCamera,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "optics" ); + mea->setOffset( daeOffsetOf(domCamera,elemOptics) ); + mea->setElementType( domCamera::domOptics::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "imager" ); + mea->setOffset( daeOffsetOf(domCamera,elemImager) ); + mea->setElementType( domCamera::domImager::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domCamera,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domCamera , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domCamera , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCamera)); + meta->validate(); + + return meta; +} + +daeElementRef +domCamera::domOptics::create(DAE& dae) +{ + domCamera::domOpticsRef ref = new domCamera::domOptics(dae); + return ref; +} + + +daeMetaElement * +domCamera::domOptics::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "optics" ); + meta->registerClass(domCamera::domOptics::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "technique_common" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics,elemTechnique_common) ); + mea->setElementType( domCamera::domOptics::domTechnique_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics,elemTechnique_array) ); + mea->setElementType( domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domCamera::domOptics)); + meta->validate(); + + return meta; +} + +daeElementRef +domCamera::domOptics::domTechnique_common::create(DAE& dae) +{ + domCamera::domOptics::domTechnique_commonRef ref = new domCamera::domOptics::domTechnique_common(dae); + return ref; +} + + +daeMetaElement * +domCamera::domOptics::domTechnique_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "technique_common" ); + meta->registerClass(domCamera::domOptics::domTechnique_common::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "orthographic" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common,elemOrthographic) ); + mea->setElementType( domCamera::domOptics::domTechnique_common::domOrthographic::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "perspective" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common,elemPerspective) ); + mea->setElementType( domCamera::domOptics::domTechnique_common::domPerspective::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCamera::domOptics::domTechnique_common,_contents)); + meta->addContentsOrder(daeOffsetOf(domCamera::domOptics::domTechnique_common,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCamera::domOptics::domTechnique_common,_CMData), 1); + meta->setElementSize(sizeof(domCamera::domOptics::domTechnique_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domCamera::domOptics::domTechnique_common::domOrthographic::create(DAE& dae) +{ + domCamera::domOptics::domTechnique_common::domOrthographicRef ref = new domCamera::domOptics::domTechnique_common::domOrthographic(dae); + return ref; +} + + +daeMetaElement * +domCamera::domOptics::domTechnique_common::domOrthographic::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "orthographic" ); + meta->registerClass(domCamera::domOptics::domTechnique_common::domOrthographic::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "xmag" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,elemXmag) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 1, 1, 0, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "ymag" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,elemYmag) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "aspect_ratio" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,elemAspect_ratio) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 1 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm = new daeMetaSequence( meta, cm, 2, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "ymag" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,elemYmag) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "aspect_ratio" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,elemAspect_ratio) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 3 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "znear" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,elemZnear) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 1, 1 ); + mea->setName( "zfar" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,elemZfar) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,_contents)); + meta->addContentsOrder(daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,_CMData), 2); + meta->setElementSize(sizeof(domCamera::domOptics::domTechnique_common::domOrthographic)); + meta->validate(); + + return meta; +} + +daeElementRef +domCamera::domOptics::domTechnique_common::domPerspective::create(DAE& dae) +{ + domCamera::domOptics::domTechnique_common::domPerspectiveRef ref = new domCamera::domOptics::domTechnique_common::domPerspective(dae); + return ref; +} + + +daeMetaElement * +domCamera::domOptics::domTechnique_common::domPerspective::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "perspective" ); + meta->registerClass(domCamera::domOptics::domTechnique_common::domPerspective::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "xfov" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,elemXfov) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 1, 1, 0, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "yfov" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,elemYfov) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "aspect_ratio" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,elemAspect_ratio) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 1 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "yfov" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,elemYfov) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "aspect_ratio" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,elemAspect_ratio) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 3 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "znear" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,elemZnear) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 1, 1 ); + mea->setName( "zfar" ); + mea->setOffset( daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,elemZfar) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,_contents)); + meta->addContentsOrder(daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,_CMData), 2); + meta->setElementSize(sizeof(domCamera::domOptics::domTechnique_common::domPerspective)); + meta->validate(); + + return meta; +} + +daeElementRef +domCamera::domImager::create(DAE& dae) +{ + domCamera::domImagerRef ref = new domCamera::domImager(dae); + return ref; +} + + +daeMetaElement * +domCamera::domImager::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "imager" ); + meta->registerClass(domCamera::domImager::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, -1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domCamera::domImager,elemTechnique_array) ); + mea->setElementType( domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domCamera::domImager,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domCamera::domImager)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCapsule.cpp b/1.4.0/dom/src/1.4/dom/domCapsule.cpp new file mode 100644 index 0000000..b7bd465 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCapsule.cpp @@ -0,0 +1,143 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCapsule.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCapsule::create(DAE& dae) +{ + domCapsuleRef ref = new domCapsule(dae); + return ref; +} + + +daeMetaElement * +domCapsule::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "capsule" ); + meta->registerClass(domCapsule::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "height" ); + mea->setOffset( daeOffsetOf(domCapsule,elemHeight) ); + mea->setElementType( domCapsule::domHeight::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "radius" ); + mea->setOffset( daeOffsetOf(domCapsule,elemRadius) ); + mea->setElementType( domCapsule::domRadius::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domCapsule,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domCapsule)); + meta->validate(); + + return meta; +} + +daeElementRef +domCapsule::domHeight::create(DAE& dae) +{ + domCapsule::domHeightRef ref = new domCapsule::domHeight(dae); + return ref; +} + + +daeMetaElement * +domCapsule::domHeight::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "height" ); + meta->registerClass(domCapsule::domHeight::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domCapsule::domHeight , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCapsule::domHeight)); + meta->validate(); + + return meta; +} + +daeElementRef +domCapsule::domRadius::create(DAE& dae) +{ + domCapsule::domRadiusRef ref = new domCapsule::domRadius(dae); + return ref; +} + + +daeMetaElement * +domCapsule::domRadius::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "radius" ); + meta->registerClass(domCapsule::domRadius::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domCapsule::domRadius , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCapsule::domRadius)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCg_connect_param.cpp b/1.4.0/dom/src/1.4/dom/domCg_connect_param.cpp new file mode 100644 index 0000000..dfcb875 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCg_connect_param.cpp @@ -0,0 +1,59 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCg_connect_param.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCg_connect_param::create(DAE& dae) +{ + domCg_connect_paramRef ref = new domCg_connect_param(dae); + return ref; +} + + +daeMetaElement * +domCg_connect_param::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cg_connect_param" ); + meta->registerClass(domCg_connect_param::create); + + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("Cg_identifier")); + ma->setOffset( daeOffsetOf( domCg_connect_param , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_connect_param)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCg_newarray_type.cpp b/1.4.0/dom/src/1.4/dom/domCg_newarray_type.cpp new file mode 100644 index 0000000..ce2241e --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCg_newarray_type.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCg_newarray_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCg_newarray_type::create(DAE& dae) +{ + domCg_newarray_typeRef ref = new domCg_newarray_type(dae); + return ref; +} + + +daeMetaElement * +domCg_newarray_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cg_newarray_type" ); + meta->registerClass(domCg_newarray_type::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "cg_param_type" ); + mea->setOffset( daeOffsetOf(domCg_newarray_type,elemCg_param_type_array) ); + mea->setElementType( domCg_param_type::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "array" ); + mea->setOffset( daeOffsetOf(domCg_newarray_type,elemArray_array) ); + mea->setElementType( domCg_newarray_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "usertype" ); + mea->setOffset( daeOffsetOf(domCg_newarray_type,elemUsertype_array) ); + mea->setElementType( domCg_setuser_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "connect_param" ); + mea->setOffset( daeOffsetOf(domCg_newarray_type,elemConnect_param_array) ); + mea->setElementType( domCg_connect_param::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3000 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCg_newarray_type,_contents)); + meta->addContentsOrder(daeOffsetOf(domCg_newarray_type,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCg_newarray_type,_CMData), 1); + // Add attribute: length + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "length" ); + ma->setType( dae.getAtomicTypes().get("xsPositiveInteger")); + ma->setOffset( daeOffsetOf( domCg_newarray_type , attrLength )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_newarray_type)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCg_newparam.cpp b/1.4.0/dom/src/1.4/dom/domCg_newparam.cpp new file mode 100644 index 0000000..7dc5335 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCg_newparam.cpp @@ -0,0 +1,183 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCg_newparam.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCg_newparam::create(DAE& dae) +{ + domCg_newparamRef ref = new domCg_newparam(dae); + return ref; +} + + +daeMetaElement * +domCg_newparam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cg_newparam" ); + meta->registerClass(domCg_newparam::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domCg_newparam,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "semantic" ); + mea->setOffset( daeOffsetOf(domCg_newparam,elemSemantic) ); + mea->setElementType( domCg_newparam::domSemantic::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "modifier" ); + mea->setOffset( daeOffsetOf(domCg_newparam,elemModifier) ); + mea->setElementType( domCg_newparam::domModifier::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 3, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "cg_param_type" ); + mea->setOffset( daeOffsetOf(domCg_newparam,elemCg_param_type) ); + mea->setElementType( domCg_param_type::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "usertype" ); + mea->setOffset( daeOffsetOf(domCg_newparam,elemUsertype) ); + mea->setElementType( domCg_setuser_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "array" ); + mea->setOffset( daeOffsetOf(domCg_newparam,elemArray) ); + mea->setElementType( domCg_newarray_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCg_newparam,_contents)); + meta->addContentsOrder(daeOffsetOf(domCg_newparam,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCg_newparam,_CMData), 1); + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("Cg_identifier")); + ma->setOffset( daeOffsetOf( domCg_newparam , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_newparam)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_newparam::domSemantic::create(DAE& dae) +{ + domCg_newparam::domSemanticRef ref = new domCg_newparam::domSemantic(dae); + return ref; +} + + +daeMetaElement * +domCg_newparam::domSemantic::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "semantic" ); + meta->registerClass(domCg_newparam::domSemantic::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domCg_newparam::domSemantic , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_newparam::domSemantic)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_newparam::domModifier::create(DAE& dae) +{ + domCg_newparam::domModifierRef ref = new domCg_newparam::domModifier(dae); + return ref; +} + + +daeMetaElement * +domCg_newparam::domModifier::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "modifier" ); + meta->registerClass(domCg_newparam::domModifier::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_modifier_enum_common")); + ma->setOffset( daeOffsetOf( domCg_newparam::domModifier , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_newparam::domModifier)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCg_param_type.cpp b/1.4.0/dom/src/1.4/dom/domCg_param_type.cpp new file mode 100644 index 0000000..5a36e00 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCg_param_type.cpp @@ -0,0 +1,4594 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCg_param_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCg_param_type::create(DAE& dae) +{ + domCg_param_typeRef ref = new domCg_param_type(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cg_param_type" ); + meta->registerClass(domCg_param_type::create); + + meta->setIsTransparent( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool) ); + mea->setElementType( domCg_param_type::domBool::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool1) ); + mea->setElementType( domCg_param_type::domBool1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool2) ); + mea->setElementType( domCg_param_type::domBool2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool3) ); + mea->setElementType( domCg_param_type::domBool3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool4) ); + mea->setElementType( domCg_param_type::domBool4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool1x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool1x1) ); + mea->setElementType( domCg_param_type::domBool1x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool1x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool1x2) ); + mea->setElementType( domCg_param_type::domBool1x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool1x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool1x3) ); + mea->setElementType( domCg_param_type::domBool1x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool1x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool1x4) ); + mea->setElementType( domCg_param_type::domBool1x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool2x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool2x1) ); + mea->setElementType( domCg_param_type::domBool2x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool2x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool2x2) ); + mea->setElementType( domCg_param_type::domBool2x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool2x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool2x3) ); + mea->setElementType( domCg_param_type::domBool2x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool2x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool2x4) ); + mea->setElementType( domCg_param_type::domBool2x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool3x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool3x1) ); + mea->setElementType( domCg_param_type::domBool3x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool3x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool3x2) ); + mea->setElementType( domCg_param_type::domBool3x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool3x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool3x3) ); + mea->setElementType( domCg_param_type::domBool3x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool3x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool3x4) ); + mea->setElementType( domCg_param_type::domBool3x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool4x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool4x1) ); + mea->setElementType( domCg_param_type::domBool4x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool4x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool4x2) ); + mea->setElementType( domCg_param_type::domBool4x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool4x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool4x3) ); + mea->setElementType( domCg_param_type::domBool4x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool4x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemBool4x4) ); + mea->setElementType( domCg_param_type::domBool4x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat) ); + mea->setElementType( domCg_param_type::domFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat1) ); + mea->setElementType( domCg_param_type::domFloat1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat2) ); + mea->setElementType( domCg_param_type::domFloat2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat3) ); + mea->setElementType( domCg_param_type::domFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat4) ); + mea->setElementType( domCg_param_type::domFloat4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float1x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat1x1) ); + mea->setElementType( domCg_param_type::domFloat1x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float1x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat1x2) ); + mea->setElementType( domCg_param_type::domFloat1x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float1x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat1x3) ); + mea->setElementType( domCg_param_type::domFloat1x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float1x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat1x4) ); + mea->setElementType( domCg_param_type::domFloat1x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat2x1) ); + mea->setElementType( domCg_param_type::domFloat2x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat2x2) ); + mea->setElementType( domCg_param_type::domFloat2x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat2x3) ); + mea->setElementType( domCg_param_type::domFloat2x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat2x4) ); + mea->setElementType( domCg_param_type::domFloat2x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat3x1) ); + mea->setElementType( domCg_param_type::domFloat3x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat3x2) ); + mea->setElementType( domCg_param_type::domFloat3x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat3x3) ); + mea->setElementType( domCg_param_type::domFloat3x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat3x4) ); + mea->setElementType( domCg_param_type::domFloat3x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat4x1) ); + mea->setElementType( domCg_param_type::domFloat4x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat4x2) ); + mea->setElementType( domCg_param_type::domFloat4x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat4x3) ); + mea->setElementType( domCg_param_type::domFloat4x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFloat4x4) ); + mea->setElementType( domCg_param_type::domFloat4x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt) ); + mea->setElementType( domCg_param_type::domInt::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt1) ); + mea->setElementType( domCg_param_type::domInt1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt2) ); + mea->setElementType( domCg_param_type::domInt2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt3) ); + mea->setElementType( domCg_param_type::domInt3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt4) ); + mea->setElementType( domCg_param_type::domInt4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int1x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt1x1) ); + mea->setElementType( domCg_param_type::domInt1x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int1x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt1x2) ); + mea->setElementType( domCg_param_type::domInt1x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int1x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt1x3) ); + mea->setElementType( domCg_param_type::domInt1x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int1x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt1x4) ); + mea->setElementType( domCg_param_type::domInt1x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int2x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt2x1) ); + mea->setElementType( domCg_param_type::domInt2x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int2x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt2x2) ); + mea->setElementType( domCg_param_type::domInt2x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int2x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt2x3) ); + mea->setElementType( domCg_param_type::domInt2x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int2x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt2x4) ); + mea->setElementType( domCg_param_type::domInt2x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int3x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt3x1) ); + mea->setElementType( domCg_param_type::domInt3x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int3x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt3x2) ); + mea->setElementType( domCg_param_type::domInt3x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int3x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt3x3) ); + mea->setElementType( domCg_param_type::domInt3x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int3x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt3x4) ); + mea->setElementType( domCg_param_type::domInt3x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int4x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt4x1) ); + mea->setElementType( domCg_param_type::domInt4x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int4x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt4x2) ); + mea->setElementType( domCg_param_type::domInt4x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int4x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt4x3) ); + mea->setElementType( domCg_param_type::domInt4x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int4x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemInt4x4) ); + mea->setElementType( domCg_param_type::domInt4x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf) ); + mea->setElementType( domCg_param_type::domHalf::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf1) ); + mea->setElementType( domCg_param_type::domHalf1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf2) ); + mea->setElementType( domCg_param_type::domHalf2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf3) ); + mea->setElementType( domCg_param_type::domHalf3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf4) ); + mea->setElementType( domCg_param_type::domHalf4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half1x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf1x1) ); + mea->setElementType( domCg_param_type::domHalf1x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half1x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf1x2) ); + mea->setElementType( domCg_param_type::domHalf1x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half1x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf1x3) ); + mea->setElementType( domCg_param_type::domHalf1x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half1x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf1x4) ); + mea->setElementType( domCg_param_type::domHalf1x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half2x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf2x1) ); + mea->setElementType( domCg_param_type::domHalf2x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half2x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf2x2) ); + mea->setElementType( domCg_param_type::domHalf2x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half2x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf2x3) ); + mea->setElementType( domCg_param_type::domHalf2x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half2x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf2x4) ); + mea->setElementType( domCg_param_type::domHalf2x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half3x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf3x1) ); + mea->setElementType( domCg_param_type::domHalf3x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half3x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf3x2) ); + mea->setElementType( domCg_param_type::domHalf3x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half3x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf3x3) ); + mea->setElementType( domCg_param_type::domHalf3x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half3x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf3x4) ); + mea->setElementType( domCg_param_type::domHalf3x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half4x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf4x1) ); + mea->setElementType( domCg_param_type::domHalf4x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half4x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf4x2) ); + mea->setElementType( domCg_param_type::domHalf4x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half4x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf4x3) ); + mea->setElementType( domCg_param_type::domHalf4x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "half4x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemHalf4x4) ); + mea->setElementType( domCg_param_type::domHalf4x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed) ); + mea->setElementType( domCg_param_type::domFixed::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed1) ); + mea->setElementType( domCg_param_type::domFixed1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed2) ); + mea->setElementType( domCg_param_type::domFixed2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed3) ); + mea->setElementType( domCg_param_type::domFixed3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed4) ); + mea->setElementType( domCg_param_type::domFixed4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed1x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed1x1) ); + mea->setElementType( domCg_param_type::domFixed1x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed1x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed1x2) ); + mea->setElementType( domCg_param_type::domFixed1x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed1x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed1x3) ); + mea->setElementType( domCg_param_type::domFixed1x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed1x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed1x4) ); + mea->setElementType( domCg_param_type::domFixed1x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed2x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed2x1) ); + mea->setElementType( domCg_param_type::domFixed2x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed2x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed2x2) ); + mea->setElementType( domCg_param_type::domFixed2x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed2x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed2x3) ); + mea->setElementType( domCg_param_type::domFixed2x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed2x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed2x4) ); + mea->setElementType( domCg_param_type::domFixed2x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed3x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed3x1) ); + mea->setElementType( domCg_param_type::domFixed3x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed3x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed3x2) ); + mea->setElementType( domCg_param_type::domFixed3x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed3x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed3x3) ); + mea->setElementType( domCg_param_type::domFixed3x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed3x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed3x4) ); + mea->setElementType( domCg_param_type::domFixed3x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed4x1" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed4x1) ); + mea->setElementType( domCg_param_type::domFixed4x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed4x2" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed4x2) ); + mea->setElementType( domCg_param_type::domFixed4x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed4x3" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed4x3) ); + mea->setElementType( domCg_param_type::domFixed4x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fixed4x4" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemFixed4x4) ); + mea->setElementType( domCg_param_type::domFixed4x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "surface" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemSurface) ); + mea->setElementType( domCg_surface_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sampler1D" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemSampler1D) ); + mea->setElementType( domCg_sampler1D::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sampler2D" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemSampler2D) ); + mea->setElementType( domCg_sampler2D::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sampler3D" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemSampler3D) ); + mea->setElementType( domCg_sampler3D::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "samplerRECT" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemSamplerRECT) ); + mea->setElementType( domCg_samplerRECT::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "samplerCUBE" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemSamplerCUBE) ); + mea->setElementType( domCg_samplerCUBE::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "samplerDEPTH" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemSamplerDEPTH) ); + mea->setElementType( domCg_samplerDEPTH::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "string" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemString) ); + mea->setElementType( domCg_param_type::domString::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "enum" ); + mea->setOffset( daeOffsetOf(domCg_param_type,elemEnum) ); + mea->setElementType( domCg_param_type::domEnum::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCg_param_type,_contents)); + meta->addContentsOrder(daeOffsetOf(domCg_param_type,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCg_param_type,_CMData), 1); + meta->setElementSize(sizeof(domCg_param_type)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool::create(DAE& dae) +{ + domCg_param_type::domBoolRef ref = new domCg_param_type::domBool(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool" ); + meta->registerClass(domCg_param_type::domBool::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool1::create(DAE& dae) +{ + domCg_param_type::domBool1Ref ref = new domCg_param_type::domBool1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool1" ); + meta->registerClass(domCg_param_type::domBool1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool2::create(DAE& dae) +{ + domCg_param_type::domBool2Ref ref = new domCg_param_type::domBool2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool2" ); + meta->registerClass(domCg_param_type::domBool2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool3::create(DAE& dae) +{ + domCg_param_type::domBool3Ref ref = new domCg_param_type::domBool3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool3" ); + meta->registerClass(domCg_param_type::domBool3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool4::create(DAE& dae) +{ + domCg_param_type::domBool4Ref ref = new domCg_param_type::domBool4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool4" ); + meta->registerClass(domCg_param_type::domBool4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool1x1::create(DAE& dae) +{ + domCg_param_type::domBool1x1Ref ref = new domCg_param_type::domBool1x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool1x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool1x1" ); + meta->registerClass(domCg_param_type::domBool1x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool1x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool1x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool1x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool1x2::create(DAE& dae) +{ + domCg_param_type::domBool1x2Ref ref = new domCg_param_type::domBool1x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool1x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool1x2" ); + meta->registerClass(domCg_param_type::domBool1x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool1x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool1x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool1x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool1x3::create(DAE& dae) +{ + domCg_param_type::domBool1x3Ref ref = new domCg_param_type::domBool1x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool1x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool1x3" ); + meta->registerClass(domCg_param_type::domBool1x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool1x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool1x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool1x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool1x4::create(DAE& dae) +{ + domCg_param_type::domBool1x4Ref ref = new domCg_param_type::domBool1x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool1x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool1x4" ); + meta->registerClass(domCg_param_type::domBool1x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool1x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool1x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool1x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool2x1::create(DAE& dae) +{ + domCg_param_type::domBool2x1Ref ref = new domCg_param_type::domBool2x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool2x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool2x1" ); + meta->registerClass(domCg_param_type::domBool2x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool2x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool2x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool2x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool2x2::create(DAE& dae) +{ + domCg_param_type::domBool2x2Ref ref = new domCg_param_type::domBool2x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool2x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool2x2" ); + meta->registerClass(domCg_param_type::domBool2x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool2x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool2x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool2x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool2x3::create(DAE& dae) +{ + domCg_param_type::domBool2x3Ref ref = new domCg_param_type::domBool2x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool2x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool2x3" ); + meta->registerClass(domCg_param_type::domBool2x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool2x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool2x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool2x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool2x4::create(DAE& dae) +{ + domCg_param_type::domBool2x4Ref ref = new domCg_param_type::domBool2x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool2x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool2x4" ); + meta->registerClass(domCg_param_type::domBool2x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool2x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool2x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool2x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool3x1::create(DAE& dae) +{ + domCg_param_type::domBool3x1Ref ref = new domCg_param_type::domBool3x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool3x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool3x1" ); + meta->registerClass(domCg_param_type::domBool3x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool3x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool3x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool3x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool3x2::create(DAE& dae) +{ + domCg_param_type::domBool3x2Ref ref = new domCg_param_type::domBool3x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool3x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool3x2" ); + meta->registerClass(domCg_param_type::domBool3x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool3x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool3x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool3x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool3x3::create(DAE& dae) +{ + domCg_param_type::domBool3x3Ref ref = new domCg_param_type::domBool3x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool3x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool3x3" ); + meta->registerClass(domCg_param_type::domBool3x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool3x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool3x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool3x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool3x4::create(DAE& dae) +{ + domCg_param_type::domBool3x4Ref ref = new domCg_param_type::domBool3x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool3x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool3x4" ); + meta->registerClass(domCg_param_type::domBool3x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool3x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool3x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool3x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool4x1::create(DAE& dae) +{ + domCg_param_type::domBool4x1Ref ref = new domCg_param_type::domBool4x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool4x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool4x1" ); + meta->registerClass(domCg_param_type::domBool4x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool4x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool4x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool4x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool4x2::create(DAE& dae) +{ + domCg_param_type::domBool4x2Ref ref = new domCg_param_type::domBool4x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool4x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool4x2" ); + meta->registerClass(domCg_param_type::domBool4x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool4x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool4x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool4x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool4x3::create(DAE& dae) +{ + domCg_param_type::domBool4x3Ref ref = new domCg_param_type::domBool4x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool4x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool4x3" ); + meta->registerClass(domCg_param_type::domBool4x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool4x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool4x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool4x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domBool4x4::create(DAE& dae) +{ + domCg_param_type::domBool4x4Ref ref = new domCg_param_type::domBool4x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domBool4x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool4x4" ); + meta->registerClass(domCg_param_type::domBool4x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_bool4x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domBool4x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domBool4x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat::create(DAE& dae) +{ + domCg_param_type::domFloatRef ref = new domCg_param_type::domFloat(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float" ); + meta->registerClass(domCg_param_type::domFloat::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat1::create(DAE& dae) +{ + domCg_param_type::domFloat1Ref ref = new domCg_param_type::domFloat1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float1" ); + meta->registerClass(domCg_param_type::domFloat1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat2::create(DAE& dae) +{ + domCg_param_type::domFloat2Ref ref = new domCg_param_type::domFloat2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2" ); + meta->registerClass(domCg_param_type::domFloat2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat3::create(DAE& dae) +{ + domCg_param_type::domFloat3Ref ref = new domCg_param_type::domFloat3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3" ); + meta->registerClass(domCg_param_type::domFloat3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat4::create(DAE& dae) +{ + domCg_param_type::domFloat4Ref ref = new domCg_param_type::domFloat4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4" ); + meta->registerClass(domCg_param_type::domFloat4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat1x1::create(DAE& dae) +{ + domCg_param_type::domFloat1x1Ref ref = new domCg_param_type::domFloat1x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat1x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float1x1" ); + meta->registerClass(domCg_param_type::domFloat1x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float1x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat1x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat1x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat1x2::create(DAE& dae) +{ + domCg_param_type::domFloat1x2Ref ref = new domCg_param_type::domFloat1x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat1x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float1x2" ); + meta->registerClass(domCg_param_type::domFloat1x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float1x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat1x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat1x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat1x3::create(DAE& dae) +{ + domCg_param_type::domFloat1x3Ref ref = new domCg_param_type::domFloat1x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat1x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float1x3" ); + meta->registerClass(domCg_param_type::domFloat1x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float1x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat1x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat1x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat1x4::create(DAE& dae) +{ + domCg_param_type::domFloat1x4Ref ref = new domCg_param_type::domFloat1x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat1x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float1x4" ); + meta->registerClass(domCg_param_type::domFloat1x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float1x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat1x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat1x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat2x1::create(DAE& dae) +{ + domCg_param_type::domFloat2x1Ref ref = new domCg_param_type::domFloat2x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat2x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2x1" ); + meta->registerClass(domCg_param_type::domFloat2x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float2x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat2x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat2x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat2x2::create(DAE& dae) +{ + domCg_param_type::domFloat2x2Ref ref = new domCg_param_type::domFloat2x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat2x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2x2" ); + meta->registerClass(domCg_param_type::domFloat2x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float2x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat2x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat2x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat2x3::create(DAE& dae) +{ + domCg_param_type::domFloat2x3Ref ref = new domCg_param_type::domFloat2x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat2x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2x3" ); + meta->registerClass(domCg_param_type::domFloat2x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float2x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat2x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat2x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat2x4::create(DAE& dae) +{ + domCg_param_type::domFloat2x4Ref ref = new domCg_param_type::domFloat2x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat2x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2x4" ); + meta->registerClass(domCg_param_type::domFloat2x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float2x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat2x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat2x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat3x1::create(DAE& dae) +{ + domCg_param_type::domFloat3x1Ref ref = new domCg_param_type::domFloat3x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat3x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3x1" ); + meta->registerClass(domCg_param_type::domFloat3x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float3x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat3x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat3x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat3x2::create(DAE& dae) +{ + domCg_param_type::domFloat3x2Ref ref = new domCg_param_type::domFloat3x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat3x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3x2" ); + meta->registerClass(domCg_param_type::domFloat3x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float3x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat3x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat3x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat3x3::create(DAE& dae) +{ + domCg_param_type::domFloat3x3Ref ref = new domCg_param_type::domFloat3x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat3x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3x3" ); + meta->registerClass(domCg_param_type::domFloat3x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float3x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat3x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat3x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat3x4::create(DAE& dae) +{ + domCg_param_type::domFloat3x4Ref ref = new domCg_param_type::domFloat3x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat3x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3x4" ); + meta->registerClass(domCg_param_type::domFloat3x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float3x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat3x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat3x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat4x1::create(DAE& dae) +{ + domCg_param_type::domFloat4x1Ref ref = new domCg_param_type::domFloat4x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat4x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4x1" ); + meta->registerClass(domCg_param_type::domFloat4x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float4x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat4x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat4x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat4x2::create(DAE& dae) +{ + domCg_param_type::domFloat4x2Ref ref = new domCg_param_type::domFloat4x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat4x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4x2" ); + meta->registerClass(domCg_param_type::domFloat4x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float4x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat4x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat4x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat4x3::create(DAE& dae) +{ + domCg_param_type::domFloat4x3Ref ref = new domCg_param_type::domFloat4x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat4x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4x3" ); + meta->registerClass(domCg_param_type::domFloat4x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float4x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat4x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat4x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFloat4x4::create(DAE& dae) +{ + domCg_param_type::domFloat4x4Ref ref = new domCg_param_type::domFloat4x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFloat4x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4x4" ); + meta->registerClass(domCg_param_type::domFloat4x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_float4x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFloat4x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFloat4x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt::create(DAE& dae) +{ + domCg_param_type::domIntRef ref = new domCg_param_type::domInt(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int" ); + meta->registerClass(domCg_param_type::domInt::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt1::create(DAE& dae) +{ + domCg_param_type::domInt1Ref ref = new domCg_param_type::domInt1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int1" ); + meta->registerClass(domCg_param_type::domInt1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt2::create(DAE& dae) +{ + domCg_param_type::domInt2Ref ref = new domCg_param_type::domInt2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int2" ); + meta->registerClass(domCg_param_type::domInt2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt3::create(DAE& dae) +{ + domCg_param_type::domInt3Ref ref = new domCg_param_type::domInt3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int3" ); + meta->registerClass(domCg_param_type::domInt3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt4::create(DAE& dae) +{ + domCg_param_type::domInt4Ref ref = new domCg_param_type::domInt4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int4" ); + meta->registerClass(domCg_param_type::domInt4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt1x1::create(DAE& dae) +{ + domCg_param_type::domInt1x1Ref ref = new domCg_param_type::domInt1x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt1x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int1x1" ); + meta->registerClass(domCg_param_type::domInt1x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int1x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt1x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt1x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt1x2::create(DAE& dae) +{ + domCg_param_type::domInt1x2Ref ref = new domCg_param_type::domInt1x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt1x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int1x2" ); + meta->registerClass(domCg_param_type::domInt1x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int1x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt1x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt1x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt1x3::create(DAE& dae) +{ + domCg_param_type::domInt1x3Ref ref = new domCg_param_type::domInt1x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt1x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int1x3" ); + meta->registerClass(domCg_param_type::domInt1x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int1x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt1x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt1x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt1x4::create(DAE& dae) +{ + domCg_param_type::domInt1x4Ref ref = new domCg_param_type::domInt1x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt1x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int1x4" ); + meta->registerClass(domCg_param_type::domInt1x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int1x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt1x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt1x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt2x1::create(DAE& dae) +{ + domCg_param_type::domInt2x1Ref ref = new domCg_param_type::domInt2x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt2x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int2x1" ); + meta->registerClass(domCg_param_type::domInt2x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int2x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt2x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt2x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt2x2::create(DAE& dae) +{ + domCg_param_type::domInt2x2Ref ref = new domCg_param_type::domInt2x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt2x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int2x2" ); + meta->registerClass(domCg_param_type::domInt2x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int2x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt2x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt2x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt2x3::create(DAE& dae) +{ + domCg_param_type::domInt2x3Ref ref = new domCg_param_type::domInt2x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt2x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int2x3" ); + meta->registerClass(domCg_param_type::domInt2x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int2x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt2x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt2x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt2x4::create(DAE& dae) +{ + domCg_param_type::domInt2x4Ref ref = new domCg_param_type::domInt2x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt2x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int2x4" ); + meta->registerClass(domCg_param_type::domInt2x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int2x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt2x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt2x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt3x1::create(DAE& dae) +{ + domCg_param_type::domInt3x1Ref ref = new domCg_param_type::domInt3x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt3x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int3x1" ); + meta->registerClass(domCg_param_type::domInt3x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int3x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt3x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt3x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt3x2::create(DAE& dae) +{ + domCg_param_type::domInt3x2Ref ref = new domCg_param_type::domInt3x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt3x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int3x2" ); + meta->registerClass(domCg_param_type::domInt3x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int3x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt3x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt3x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt3x3::create(DAE& dae) +{ + domCg_param_type::domInt3x3Ref ref = new domCg_param_type::domInt3x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt3x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int3x3" ); + meta->registerClass(domCg_param_type::domInt3x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int3x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt3x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt3x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt3x4::create(DAE& dae) +{ + domCg_param_type::domInt3x4Ref ref = new domCg_param_type::domInt3x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt3x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int3x4" ); + meta->registerClass(domCg_param_type::domInt3x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int3x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt3x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt3x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt4x1::create(DAE& dae) +{ + domCg_param_type::domInt4x1Ref ref = new domCg_param_type::domInt4x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt4x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int4x1" ); + meta->registerClass(domCg_param_type::domInt4x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int4x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt4x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt4x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt4x2::create(DAE& dae) +{ + domCg_param_type::domInt4x2Ref ref = new domCg_param_type::domInt4x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt4x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int4x2" ); + meta->registerClass(domCg_param_type::domInt4x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int4x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt4x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt4x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt4x3::create(DAE& dae) +{ + domCg_param_type::domInt4x3Ref ref = new domCg_param_type::domInt4x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt4x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int4x3" ); + meta->registerClass(domCg_param_type::domInt4x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int4x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt4x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt4x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domInt4x4::create(DAE& dae) +{ + domCg_param_type::domInt4x4Ref ref = new domCg_param_type::domInt4x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domInt4x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int4x4" ); + meta->registerClass(domCg_param_type::domInt4x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_int4x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domInt4x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domInt4x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf::create(DAE& dae) +{ + domCg_param_type::domHalfRef ref = new domCg_param_type::domHalf(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half" ); + meta->registerClass(domCg_param_type::domHalf::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf1::create(DAE& dae) +{ + domCg_param_type::domHalf1Ref ref = new domCg_param_type::domHalf1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half1" ); + meta->registerClass(domCg_param_type::domHalf1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf2::create(DAE& dae) +{ + domCg_param_type::domHalf2Ref ref = new domCg_param_type::domHalf2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half2" ); + meta->registerClass(domCg_param_type::domHalf2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf3::create(DAE& dae) +{ + domCg_param_type::domHalf3Ref ref = new domCg_param_type::domHalf3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half3" ); + meta->registerClass(domCg_param_type::domHalf3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf4::create(DAE& dae) +{ + domCg_param_type::domHalf4Ref ref = new domCg_param_type::domHalf4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half4" ); + meta->registerClass(domCg_param_type::domHalf4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf1x1::create(DAE& dae) +{ + domCg_param_type::domHalf1x1Ref ref = new domCg_param_type::domHalf1x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf1x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half1x1" ); + meta->registerClass(domCg_param_type::domHalf1x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half1x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf1x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf1x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf1x2::create(DAE& dae) +{ + domCg_param_type::domHalf1x2Ref ref = new domCg_param_type::domHalf1x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf1x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half1x2" ); + meta->registerClass(domCg_param_type::domHalf1x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half1x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf1x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf1x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf1x3::create(DAE& dae) +{ + domCg_param_type::domHalf1x3Ref ref = new domCg_param_type::domHalf1x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf1x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half1x3" ); + meta->registerClass(domCg_param_type::domHalf1x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half1x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf1x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf1x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf1x4::create(DAE& dae) +{ + domCg_param_type::domHalf1x4Ref ref = new domCg_param_type::domHalf1x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf1x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half1x4" ); + meta->registerClass(domCg_param_type::domHalf1x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half1x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf1x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf1x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf2x1::create(DAE& dae) +{ + domCg_param_type::domHalf2x1Ref ref = new domCg_param_type::domHalf2x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf2x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half2x1" ); + meta->registerClass(domCg_param_type::domHalf2x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half2x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf2x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf2x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf2x2::create(DAE& dae) +{ + domCg_param_type::domHalf2x2Ref ref = new domCg_param_type::domHalf2x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf2x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half2x2" ); + meta->registerClass(domCg_param_type::domHalf2x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half2x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf2x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf2x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf2x3::create(DAE& dae) +{ + domCg_param_type::domHalf2x3Ref ref = new domCg_param_type::domHalf2x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf2x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half2x3" ); + meta->registerClass(domCg_param_type::domHalf2x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half2x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf2x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf2x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf2x4::create(DAE& dae) +{ + domCg_param_type::domHalf2x4Ref ref = new domCg_param_type::domHalf2x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf2x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half2x4" ); + meta->registerClass(domCg_param_type::domHalf2x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half2x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf2x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf2x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf3x1::create(DAE& dae) +{ + domCg_param_type::domHalf3x1Ref ref = new domCg_param_type::domHalf3x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf3x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half3x1" ); + meta->registerClass(domCg_param_type::domHalf3x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half3x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf3x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf3x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf3x2::create(DAE& dae) +{ + domCg_param_type::domHalf3x2Ref ref = new domCg_param_type::domHalf3x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf3x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half3x2" ); + meta->registerClass(domCg_param_type::domHalf3x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half3x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf3x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf3x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf3x3::create(DAE& dae) +{ + domCg_param_type::domHalf3x3Ref ref = new domCg_param_type::domHalf3x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf3x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half3x3" ); + meta->registerClass(domCg_param_type::domHalf3x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half3x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf3x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf3x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf3x4::create(DAE& dae) +{ + domCg_param_type::domHalf3x4Ref ref = new domCg_param_type::domHalf3x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf3x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half3x4" ); + meta->registerClass(domCg_param_type::domHalf3x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half3x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf3x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf3x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf4x1::create(DAE& dae) +{ + domCg_param_type::domHalf4x1Ref ref = new domCg_param_type::domHalf4x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf4x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half4x1" ); + meta->registerClass(domCg_param_type::domHalf4x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half4x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf4x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf4x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf4x2::create(DAE& dae) +{ + domCg_param_type::domHalf4x2Ref ref = new domCg_param_type::domHalf4x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf4x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half4x2" ); + meta->registerClass(domCg_param_type::domHalf4x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half4x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf4x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf4x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf4x3::create(DAE& dae) +{ + domCg_param_type::domHalf4x3Ref ref = new domCg_param_type::domHalf4x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf4x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half4x3" ); + meta->registerClass(domCg_param_type::domHalf4x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half4x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf4x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf4x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domHalf4x4::create(DAE& dae) +{ + domCg_param_type::domHalf4x4Ref ref = new domCg_param_type::domHalf4x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domHalf4x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "half4x4" ); + meta->registerClass(domCg_param_type::domHalf4x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_half4x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domHalf4x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domHalf4x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed::create(DAE& dae) +{ + domCg_param_type::domFixedRef ref = new domCg_param_type::domFixed(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed" ); + meta->registerClass(domCg_param_type::domFixed::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed1::create(DAE& dae) +{ + domCg_param_type::domFixed1Ref ref = new domCg_param_type::domFixed1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed1" ); + meta->registerClass(domCg_param_type::domFixed1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed2::create(DAE& dae) +{ + domCg_param_type::domFixed2Ref ref = new domCg_param_type::domFixed2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed2" ); + meta->registerClass(domCg_param_type::domFixed2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed3::create(DAE& dae) +{ + domCg_param_type::domFixed3Ref ref = new domCg_param_type::domFixed3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed3" ); + meta->registerClass(domCg_param_type::domFixed3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed4::create(DAE& dae) +{ + domCg_param_type::domFixed4Ref ref = new domCg_param_type::domFixed4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed4" ); + meta->registerClass(domCg_param_type::domFixed4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed1x1::create(DAE& dae) +{ + domCg_param_type::domFixed1x1Ref ref = new domCg_param_type::domFixed1x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed1x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed1x1" ); + meta->registerClass(domCg_param_type::domFixed1x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed1x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed1x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed1x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed1x2::create(DAE& dae) +{ + domCg_param_type::domFixed1x2Ref ref = new domCg_param_type::domFixed1x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed1x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed1x2" ); + meta->registerClass(domCg_param_type::domFixed1x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed1x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed1x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed1x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed1x3::create(DAE& dae) +{ + domCg_param_type::domFixed1x3Ref ref = new domCg_param_type::domFixed1x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed1x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed1x3" ); + meta->registerClass(domCg_param_type::domFixed1x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed1x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed1x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed1x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed1x4::create(DAE& dae) +{ + domCg_param_type::domFixed1x4Ref ref = new domCg_param_type::domFixed1x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed1x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed1x4" ); + meta->registerClass(domCg_param_type::domFixed1x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed1x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed1x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed1x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed2x1::create(DAE& dae) +{ + domCg_param_type::domFixed2x1Ref ref = new domCg_param_type::domFixed2x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed2x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed2x1" ); + meta->registerClass(domCg_param_type::domFixed2x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed2x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed2x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed2x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed2x2::create(DAE& dae) +{ + domCg_param_type::domFixed2x2Ref ref = new domCg_param_type::domFixed2x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed2x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed2x2" ); + meta->registerClass(domCg_param_type::domFixed2x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed2x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed2x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed2x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed2x3::create(DAE& dae) +{ + domCg_param_type::domFixed2x3Ref ref = new domCg_param_type::domFixed2x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed2x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed2x3" ); + meta->registerClass(domCg_param_type::domFixed2x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed2x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed2x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed2x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed2x4::create(DAE& dae) +{ + domCg_param_type::domFixed2x4Ref ref = new domCg_param_type::domFixed2x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed2x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed2x4" ); + meta->registerClass(domCg_param_type::domFixed2x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed2x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed2x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed2x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed3x1::create(DAE& dae) +{ + domCg_param_type::domFixed3x1Ref ref = new domCg_param_type::domFixed3x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed3x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed3x1" ); + meta->registerClass(domCg_param_type::domFixed3x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed3x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed3x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed3x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed3x2::create(DAE& dae) +{ + domCg_param_type::domFixed3x2Ref ref = new domCg_param_type::domFixed3x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed3x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed3x2" ); + meta->registerClass(domCg_param_type::domFixed3x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed3x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed3x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed3x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed3x3::create(DAE& dae) +{ + domCg_param_type::domFixed3x3Ref ref = new domCg_param_type::domFixed3x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed3x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed3x3" ); + meta->registerClass(domCg_param_type::domFixed3x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed3x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed3x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed3x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed3x4::create(DAE& dae) +{ + domCg_param_type::domFixed3x4Ref ref = new domCg_param_type::domFixed3x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed3x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed3x4" ); + meta->registerClass(domCg_param_type::domFixed3x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed3x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed3x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed3x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed4x1::create(DAE& dae) +{ + domCg_param_type::domFixed4x1Ref ref = new domCg_param_type::domFixed4x1(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed4x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed4x1" ); + meta->registerClass(domCg_param_type::domFixed4x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed4x1")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed4x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed4x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed4x2::create(DAE& dae) +{ + domCg_param_type::domFixed4x2Ref ref = new domCg_param_type::domFixed4x2(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed4x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed4x2" ); + meta->registerClass(domCg_param_type::domFixed4x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed4x2")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed4x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed4x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed4x3::create(DAE& dae) +{ + domCg_param_type::domFixed4x3Ref ref = new domCg_param_type::domFixed4x3(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed4x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed4x3" ); + meta->registerClass(domCg_param_type::domFixed4x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed4x3")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed4x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed4x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domFixed4x4::create(DAE& dae) +{ + domCg_param_type::domFixed4x4Ref ref = new domCg_param_type::domFixed4x4(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domFixed4x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fixed4x4" ); + meta->registerClass(domCg_param_type::domFixed4x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Cg_fixed4x4")); + ma->setOffset( daeOffsetOf( domCg_param_type::domFixed4x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domFixed4x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domString::create(DAE& dae) +{ + domCg_param_type::domStringRef ref = new domCg_param_type::domString(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domString::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "string" ); + meta->registerClass(domCg_param_type::domString::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domCg_param_type::domString , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domString)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_param_type::domEnum::create(DAE& dae) +{ + domCg_param_type::domEnumRef ref = new domCg_param_type::domEnum(dae); + return ref; +} + + +daeMetaElement * +domCg_param_type::domEnum::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "enum" ); + meta->registerClass(domCg_param_type::domEnum::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Gl_enumeration")); + ma->setOffset( daeOffsetOf( domCg_param_type::domEnum , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_param_type::domEnum)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCg_sampler1D.cpp b/1.4.0/dom/src/1.4/dom/domCg_sampler1D.cpp new file mode 100644 index 0000000..9e960d0 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCg_sampler1D.cpp @@ -0,0 +1,113 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCg_sampler1D.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCg_sampler1D::create(DAE& dae) +{ + domCg_sampler1DRef ref = new domCg_sampler1D(dae); + return ref; +} + + +daeMetaElement * +domCg_sampler1D::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cg_sampler1D" ); + meta->registerClass(domCg_sampler1D::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domCg_sampler1D,elemSource) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domCg_sampler1D,elemWrap_s) ); + mea->setElementType( domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domCg_sampler1D,elemMinfilter) ); + mea->setElementType( domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domCg_sampler1D,elemMagfilter) ); + mea->setElementType( domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domCg_sampler1D,elemMipfilter) ); + mea->setElementType( domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "border_color" ); + mea->setOffset( daeOffsetOf(domCg_sampler1D,elemBorder_color) ); + mea->setElementType( domBorder_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domCg_sampler1D,elemMipmap_maxlevel) ); + mea->setElementType( domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domCg_sampler1D,elemMipmap_bias) ); + mea->setElementType( domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 8, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domCg_sampler1D,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 8 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 8 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domCg_sampler1D)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCg_sampler2D.cpp b/1.4.0/dom/src/1.4/dom/domCg_sampler2D.cpp new file mode 100644 index 0000000..5d01d22 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCg_sampler2D.cpp @@ -0,0 +1,119 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCg_sampler2D.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCg_sampler2D::create(DAE& dae) +{ + domCg_sampler2DRef ref = new domCg_sampler2D(dae); + return ref; +} + + +daeMetaElement * +domCg_sampler2D::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cg_sampler2D" ); + meta->registerClass(domCg_sampler2D::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domCg_sampler2D,elemSource) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domCg_sampler2D,elemWrap_s) ); + mea->setElementType( domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domCg_sampler2D,elemWrap_t) ); + mea->setElementType( domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domCg_sampler2D,elemMinfilter) ); + mea->setElementType( domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domCg_sampler2D,elemMagfilter) ); + mea->setElementType( domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domCg_sampler2D,elemMipfilter) ); + mea->setElementType( domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "border_color" ); + mea->setOffset( daeOffsetOf(domCg_sampler2D,elemBorder_color) ); + mea->setElementType( domBorder_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domCg_sampler2D,elemMipmap_maxlevel) ); + mea->setElementType( domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 8, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domCg_sampler2D,elemMipmap_bias) ); + mea->setElementType( domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 9, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domCg_sampler2D,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 9 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 9 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domCg_sampler2D)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCg_sampler3D.cpp b/1.4.0/dom/src/1.4/dom/domCg_sampler3D.cpp new file mode 100644 index 0000000..1288e4b --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCg_sampler3D.cpp @@ -0,0 +1,125 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCg_sampler3D.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCg_sampler3D::create(DAE& dae) +{ + domCg_sampler3DRef ref = new domCg_sampler3D(dae); + return ref; +} + + +daeMetaElement * +domCg_sampler3D::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cg_sampler3D" ); + meta->registerClass(domCg_sampler3D::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domCg_sampler3D,elemSource) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domCg_sampler3D,elemWrap_s) ); + mea->setElementType( domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domCg_sampler3D,elemWrap_t) ); + mea->setElementType( domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "wrap_p" ); + mea->setOffset( daeOffsetOf(domCg_sampler3D,elemWrap_p) ); + mea->setElementType( domWrap_p::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domCg_sampler3D,elemMinfilter) ); + mea->setElementType( domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domCg_sampler3D,elemMagfilter) ); + mea->setElementType( domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domCg_sampler3D,elemMipfilter) ); + mea->setElementType( domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "border_color" ); + mea->setOffset( daeOffsetOf(domCg_sampler3D,elemBorder_color) ); + mea->setElementType( domBorder_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 8, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domCg_sampler3D,elemMipmap_maxlevel) ); + mea->setElementType( domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 9, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domCg_sampler3D,elemMipmap_bias) ); + mea->setElementType( domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 10, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domCg_sampler3D,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 10 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 10 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domCg_sampler3D)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCg_samplerCUBE.cpp b/1.4.0/dom/src/1.4/dom/domCg_samplerCUBE.cpp new file mode 100644 index 0000000..65f8e64 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCg_samplerCUBE.cpp @@ -0,0 +1,125 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCg_samplerCUBE.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCg_samplerCUBE::create(DAE& dae) +{ + domCg_samplerCUBERef ref = new domCg_samplerCUBE(dae); + return ref; +} + + +daeMetaElement * +domCg_samplerCUBE::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cg_samplerCUBE" ); + meta->registerClass(domCg_samplerCUBE::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domCg_samplerCUBE,elemSource) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domCg_samplerCUBE,elemWrap_s) ); + mea->setElementType( domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domCg_samplerCUBE,elemWrap_t) ); + mea->setElementType( domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "wrap_p" ); + mea->setOffset( daeOffsetOf(domCg_samplerCUBE,elemWrap_p) ); + mea->setElementType( domWrap_p::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domCg_samplerCUBE,elemMinfilter) ); + mea->setElementType( domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domCg_samplerCUBE,elemMagfilter) ); + mea->setElementType( domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domCg_samplerCUBE,elemMipfilter) ); + mea->setElementType( domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "border_color" ); + mea->setOffset( daeOffsetOf(domCg_samplerCUBE,elemBorder_color) ); + mea->setElementType( domBorder_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 8, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domCg_samplerCUBE,elemMipmap_maxlevel) ); + mea->setElementType( domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 9, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domCg_samplerCUBE,elemMipmap_bias) ); + mea->setElementType( domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 10, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domCg_samplerCUBE,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 10 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 10 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domCg_samplerCUBE)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCg_samplerDEPTH.cpp b/1.4.0/dom/src/1.4/dom/domCg_samplerDEPTH.cpp new file mode 100644 index 0000000..a44f657 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCg_samplerDEPTH.cpp @@ -0,0 +1,95 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCg_samplerDEPTH.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCg_samplerDEPTH::create(DAE& dae) +{ + domCg_samplerDEPTHRef ref = new domCg_samplerDEPTH(dae); + return ref; +} + + +daeMetaElement * +domCg_samplerDEPTH::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cg_samplerDEPTH" ); + meta->registerClass(domCg_samplerDEPTH::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domCg_samplerDEPTH,elemSource) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domCg_samplerDEPTH,elemWrap_s) ); + mea->setElementType( domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domCg_samplerDEPTH,elemWrap_t) ); + mea->setElementType( domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domCg_samplerDEPTH,elemMinfilter) ); + mea->setElementType( domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domCg_samplerDEPTH,elemMagfilter) ); + mea->setElementType( domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 5, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domCg_samplerDEPTH,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 5 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 5 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domCg_samplerDEPTH)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCg_samplerRECT.cpp b/1.4.0/dom/src/1.4/dom/domCg_samplerRECT.cpp new file mode 100644 index 0000000..7dbe8e7 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCg_samplerRECT.cpp @@ -0,0 +1,119 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCg_samplerRECT.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCg_samplerRECT::create(DAE& dae) +{ + domCg_samplerRECTRef ref = new domCg_samplerRECT(dae); + return ref; +} + + +daeMetaElement * +domCg_samplerRECT::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cg_samplerRECT" ); + meta->registerClass(domCg_samplerRECT::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domCg_samplerRECT,elemSource) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domCg_samplerRECT,elemWrap_s) ); + mea->setElementType( domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domCg_samplerRECT,elemWrap_t) ); + mea->setElementType( domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domCg_samplerRECT,elemMinfilter) ); + mea->setElementType( domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domCg_samplerRECT,elemMagfilter) ); + mea->setElementType( domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domCg_samplerRECT,elemMipfilter) ); + mea->setElementType( domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "border_color" ); + mea->setOffset( daeOffsetOf(domCg_samplerRECT,elemBorder_color) ); + mea->setElementType( domBorder_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domCg_samplerRECT,elemMipmap_maxlevel) ); + mea->setElementType( domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 8, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domCg_samplerRECT,elemMipmap_bias) ); + mea->setElementType( domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 9, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domCg_samplerRECT,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 9 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 9 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domCg_samplerRECT)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCg_setarray_type.cpp b/1.4.0/dom/src/1.4/dom/domCg_setarray_type.cpp new file mode 100644 index 0000000..782aba1 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCg_setarray_type.cpp @@ -0,0 +1,87 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCg_setarray_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCg_setarray_type::create(DAE& dae) +{ + domCg_setarray_typeRef ref = new domCg_setarray_type(dae); + return ref; +} + + +daeMetaElement * +domCg_setarray_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cg_setarray_type" ); + meta->registerClass(domCg_setarray_type::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "cg_param_type" ); + mea->setOffset( daeOffsetOf(domCg_setarray_type,elemCg_param_type_array) ); + mea->setElementType( domCg_param_type::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "array" ); + mea->setOffset( daeOffsetOf(domCg_setarray_type,elemArray_array) ); + mea->setElementType( domCg_setarray_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "usertype" ); + mea->setOffset( daeOffsetOf(domCg_setarray_type,elemUsertype_array) ); + mea->setElementType( domCg_setuser_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3000 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCg_setarray_type,_contents)); + meta->addContentsOrder(daeOffsetOf(domCg_setarray_type,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCg_setarray_type,_CMData), 1); + // Add attribute: length + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "length" ); + ma->setType( dae.getAtomicTypes().get("xsPositiveInteger")); + ma->setOffset( daeOffsetOf( domCg_setarray_type , attrLength )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_setarray_type)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCg_setparam.cpp b/1.4.0/dom/src/1.4/dom/domCg_setparam.cpp new file mode 100644 index 0000000..7da8e3d --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCg_setparam.cpp @@ -0,0 +1,104 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCg_setparam.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCg_setparam::create(DAE& dae) +{ + domCg_setparamRef ref = new domCg_setparam(dae); + return ref; +} + + +daeMetaElement * +domCg_setparam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cg_setparam" ); + meta->registerClass(domCg_setparam::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "cg_param_type" ); + mea->setOffset( daeOffsetOf(domCg_setparam,elemCg_param_type) ); + mea->setElementType( domCg_param_type::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "usertype" ); + mea->setOffset( daeOffsetOf(domCg_setparam,elemUsertype) ); + mea->setElementType( domCg_setuser_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "array" ); + mea->setOffset( daeOffsetOf(domCg_setparam,elemArray) ); + mea->setElementType( domCg_setarray_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "connect_param" ); + mea->setOffset( daeOffsetOf(domCg_setparam,elemConnect_param) ); + mea->setElementType( domCg_connect_param::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCg_setparam,_contents)); + meta->addContentsOrder(daeOffsetOf(domCg_setparam,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCg_setparam,_CMData), 1); + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("Cg_identifier")); + ma->setOffset( daeOffsetOf( domCg_setparam , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: program + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "program" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domCg_setparam , attrProgram )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_setparam)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCg_setparam_simple.cpp b/1.4.0/dom/src/1.4/dom/domCg_setparam_simple.cpp new file mode 100644 index 0000000..1b1aa95 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCg_setparam_simple.cpp @@ -0,0 +1,77 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCg_setparam_simple.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCg_setparam_simple::create(DAE& dae) +{ + domCg_setparam_simpleRef ref = new domCg_setparam_simple(dae); + return ref; +} + + +daeMetaElement * +domCg_setparam_simple::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cg_setparam_simple" ); + meta->registerClass(domCg_setparam_simple::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domCg_setparam_simple,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "cg_param_type" ); + mea->setOffset( daeOffsetOf(domCg_setparam_simple,elemCg_param_type) ); + mea->setElementType( domCg_param_type::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 1, 1, 1 ) ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("Cg_identifier")); + ma->setOffset( daeOffsetOf( domCg_setparam_simple , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_setparam_simple)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCg_setuser_type.cpp b/1.4.0/dom/src/1.4/dom/domCg_setuser_type.cpp new file mode 100644 index 0000000..b685573 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCg_setuser_type.cpp @@ -0,0 +1,117 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCg_setuser_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCg_setuser_type::create(DAE& dae) +{ + domCg_setuser_typeRef ref = new domCg_setuser_type(dae); + return ref; +} + + +daeMetaElement * +domCg_setuser_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cg_setuser_type" ); + meta->registerClass(domCg_setuser_type::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 0, 1 ); + + cm = new daeMetaChoice( meta, cm, 1, 0, 1, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "cg_param_type" ); + mea->setOffset( daeOffsetOf(domCg_setuser_type,elemCg_param_type_array) ); + mea->setElementType( domCg_param_type::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "array" ); + mea->setOffset( daeOffsetOf(domCg_setuser_type,elemArray_array) ); + mea->setElementType( domCg_setarray_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "usertype" ); + mea->setOffset( daeOffsetOf(domCg_setuser_type,elemUsertype_array) ); + mea->setElementType( domCg_setuser_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "connect_param" ); + mea->setOffset( daeOffsetOf(domCg_setuser_type,elemConnect_param_array) ); + mea->setElementType( domCg_connect_param::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3001, 1, -1 ); + mea->setName( "setparam" ); + mea->setOffset( daeOffsetOf(domCg_setuser_type,elemSetparam_array) ); + mea->setElementType( domCg_setparam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCg_setuser_type,_contents)); + meta->addContentsOrder(daeOffsetOf(domCg_setuser_type,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCg_setuser_type,_CMData), 2); + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("Cg_identifier")); + ma->setOffset( daeOffsetOf( domCg_setuser_type , attrName )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: source + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "source" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domCg_setuser_type , attrSource )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_setuser_type)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCg_surface_type.cpp b/1.4.0/dom/src/1.4/dom/domCg_surface_type.cpp new file mode 100644 index 0000000..597a4bc --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCg_surface_type.cpp @@ -0,0 +1,262 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCg_surface_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCg_surface_type::create(DAE& dae) +{ + domCg_surface_typeRef ref = new domCg_surface_type(dae); + return ref; +} + + +daeMetaElement * +domCg_surface_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cg_surface_type" ); + meta->registerClass(domCg_surface_type::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "fx_surface_init_common" ); + mea->setOffset( daeOffsetOf(domCg_surface_type,elemFx_surface_init_common) ); + mea->setElementType( domFx_surface_init_common::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 0, 1 ) ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "format" ); + mea->setOffset( daeOffsetOf(domCg_surface_type,elemFormat) ); + mea->setElementType( domFormat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "format_hint" ); + mea->setOffset( daeOffsetOf(domCg_surface_type,elemFormat_hint) ); + mea->setElementType( domFx_surface_format_hint_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 3, 0, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "size" ); + mea->setOffset( daeOffsetOf(domCg_surface_type,elemSize) ); + mea->setElementType( domSize::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "viewport_ratio" ); + mea->setOffset( daeOffsetOf(domCg_surface_type,elemViewport_ratio) ); + mea->setElementType( domViewport_ratio::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "mip_levels" ); + mea->setOffset( daeOffsetOf(domCg_surface_type,elemMip_levels) ); + mea->setElementType( domMip_levels::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "mipmap_generate" ); + mea->setOffset( daeOffsetOf(domCg_surface_type,elemMipmap_generate) ); + mea->setElementType( domMipmap_generate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 6, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domCg_surface_type,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 6 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm = new daeMetaSequence( meta, cm, 7, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "generator" ); + mea->setOffset( daeOffsetOf(domCg_surface_type,elemGenerator) ); + mea->setElementType( domGenerator::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 7 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCg_surface_type,_contents)); + meta->addContentsOrder(daeOffsetOf(domCg_surface_type,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCg_surface_type,_CMData), 1); + // Add attribute: type + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "type" ); + ma->setType( dae.getAtomicTypes().get("Fx_surface_type_enum")); + ma->setOffset( daeOffsetOf( domCg_surface_type , attrType )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_surface_type)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_surface_type::domGenerator::create(DAE& dae) +{ + domCg_surface_type::domGeneratorRef ref = new domCg_surface_type::domGenerator(dae); + return ref; +} + + +daeMetaElement * +domCg_surface_type::domGenerator::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "generator" ); + meta->registerClass(domCg_surface_type::domGenerator::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domCg_surface_type::domGenerator,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 1, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "code" ); + mea->setOffset( daeOffsetOf(domCg_surface_type::domGenerator,elemCode_array) ); + mea->setElementType( domFx_code_profile::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "include" ); + mea->setOffset( daeOffsetOf(domCg_surface_type::domGenerator,elemInclude_array) ); + mea->setElementType( domFx_include_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementAttribute( meta, cm, 3002, 1, 1 ); + mea->setName( "name" ); + mea->setOffset( daeOffsetOf(domCg_surface_type::domGenerator,elemName) ); + mea->setElementType( domCg_surface_type::domGenerator::domName::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3003, 0, -1 ); + mea->setName( "setparam" ); + mea->setOffset( daeOffsetOf(domCg_surface_type::domGenerator,elemSetparam_array) ); + mea->setElementType( domCg_setparam_simple::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3003 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCg_surface_type::domGenerator,_contents)); + meta->addContentsOrder(daeOffsetOf(domCg_surface_type::domGenerator,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCg_surface_type::domGenerator,_CMData), 1); + meta->setElementSize(sizeof(domCg_surface_type::domGenerator)); + meta->validate(); + + return meta; +} + +daeElementRef +domCg_surface_type::domGenerator::domName::create(DAE& dae) +{ + domCg_surface_type::domGenerator::domNameRef ref = new domCg_surface_type::domGenerator::domName(dae); + return ref; +} + + +daeMetaElement * +domCg_surface_type::domGenerator::domName::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "name" ); + meta->registerClass(domCg_surface_type::domGenerator::domName::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domCg_surface_type::domGenerator::domName , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: source + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "source" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domCg_surface_type::domGenerator::domName , attrSource )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCg_surface_type::domGenerator::domName)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domChannel.cpp b/1.4.0/dom/src/1.4/dom/domChannel.cpp new file mode 100644 index 0000000..79becf6 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domChannel.cpp @@ -0,0 +1,71 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domChannel.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domChannel::create(DAE& dae) +{ + domChannelRef ref = new domChannel(dae); + return ref; +} + + +daeMetaElement * +domChannel::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "channel" ); + meta->registerClass(domChannel::create); + + + // Add attribute: source + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "source" ); + ma->setType( dae.getAtomicTypes().get("URIFragmentType")); + ma->setOffset( daeOffsetOf( domChannel , attrSource )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: target + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "target" ); + ma->setType( dae.getAtomicTypes().get("xsToken")); + ma->setOffset( daeOffsetOf( domChannel , attrTarget )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domChannel)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCommon_color_or_texture_type.cpp b/1.4.0/dom/src/1.4/dom/domCommon_color_or_texture_type.cpp new file mode 100644 index 0000000..e80ef0b --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCommon_color_or_texture_type.cpp @@ -0,0 +1,224 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCommon_color_or_texture_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCommon_color_or_texture_type::create(DAE& dae) +{ + domCommon_color_or_texture_typeRef ref = new domCommon_color_or_texture_type(dae); + return ref; +} + + +daeMetaElement * +domCommon_color_or_texture_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "common_color_or_texture_type" ); + meta->registerClass(domCommon_color_or_texture_type::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "color" ); + mea->setOffset( daeOffsetOf(domCommon_color_or_texture_type,elemColor) ); + mea->setElementType( domCommon_color_or_texture_type::domColor::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "param" ); + mea->setOffset( daeOffsetOf(domCommon_color_or_texture_type,elemParam) ); + mea->setElementType( domCommon_color_or_texture_type::domParam::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texture" ); + mea->setOffset( daeOffsetOf(domCommon_color_or_texture_type,elemTexture) ); + mea->setElementType( domCommon_color_or_texture_type::domTexture::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCommon_color_or_texture_type,_contents)); + meta->addContentsOrder(daeOffsetOf(domCommon_color_or_texture_type,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCommon_color_or_texture_type,_CMData), 1); + meta->setElementSize(sizeof(domCommon_color_or_texture_type)); + meta->validate(); + + return meta; +} + +daeElementRef +domCommon_color_or_texture_type::domColor::create(DAE& dae) +{ + domCommon_color_or_texture_type::domColorRef ref = new domCommon_color_or_texture_type::domColor(dae); + return ref; +} + + +daeMetaElement * +domCommon_color_or_texture_type::domColor::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "color" ); + meta->registerClass(domCommon_color_or_texture_type::domColor::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_color_common")); + ma->setOffset( daeOffsetOf( domCommon_color_or_texture_type::domColor , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domCommon_color_or_texture_type::domColor , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCommon_color_or_texture_type::domColor)); + meta->validate(); + + return meta; +} + +daeElementRef +domCommon_color_or_texture_type::domParam::create(DAE& dae) +{ + domCommon_color_or_texture_type::domParamRef ref = new domCommon_color_or_texture_type::domParam(dae); + return ref; +} + + +daeMetaElement * +domCommon_color_or_texture_type::domParam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "param" ); + meta->registerClass(domCommon_color_or_texture_type::domParam::create); + + meta->setIsInnerClass( true ); + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domCommon_color_or_texture_type::domParam , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCommon_color_or_texture_type::domParam)); + meta->validate(); + + return meta; +} + +daeElementRef +domCommon_color_or_texture_type::domTexture::create(DAE& dae) +{ + domCommon_color_or_texture_type::domTextureRef ref = new domCommon_color_or_texture_type::domTexture(dae); + return ref; +} + + +daeMetaElement * +domCommon_color_or_texture_type::domTexture::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "texture" ); + meta->registerClass(domCommon_color_or_texture_type::domTexture::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domCommon_color_or_texture_type::domTexture,elemExtra) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: texture + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "texture" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domCommon_color_or_texture_type::domTexture , attrTexture )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: texcoord + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "texcoord" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domCommon_color_or_texture_type::domTexture , attrTexcoord )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCommon_color_or_texture_type::domTexture)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCommon_float_or_param_type.cpp b/1.4.0/dom/src/1.4/dom/domCommon_float_or_param_type.cpp new file mode 100644 index 0000000..171a413 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCommon_float_or_param_type.cpp @@ -0,0 +1,155 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCommon_float_or_param_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCommon_float_or_param_type::create(DAE& dae) +{ + domCommon_float_or_param_typeRef ref = new domCommon_float_or_param_type(dae); + return ref; +} + + +daeMetaElement * +domCommon_float_or_param_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "common_float_or_param_type" ); + meta->registerClass(domCommon_float_or_param_type::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float" ); + mea->setOffset( daeOffsetOf(domCommon_float_or_param_type,elemFloat) ); + mea->setElementType( domCommon_float_or_param_type::domFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "param" ); + mea->setOffset( daeOffsetOf(domCommon_float_or_param_type,elemParam) ); + mea->setElementType( domCommon_float_or_param_type::domParam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCommon_float_or_param_type,_contents)); + meta->addContentsOrder(daeOffsetOf(domCommon_float_or_param_type,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCommon_float_or_param_type,_CMData), 1); + meta->setElementSize(sizeof(domCommon_float_or_param_type)); + meta->validate(); + + return meta; +} + +daeElementRef +domCommon_float_or_param_type::domFloat::create(DAE& dae) +{ + domCommon_float_or_param_type::domFloatRef ref = new domCommon_float_or_param_type::domFloat(dae); + return ref; +} + + +daeMetaElement * +domCommon_float_or_param_type::domFloat::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float" ); + meta->registerClass(domCommon_float_or_param_type::domFloat::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domCommon_float_or_param_type::domFloat , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domCommon_float_or_param_type::domFloat , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCommon_float_or_param_type::domFloat)); + meta->validate(); + + return meta; +} + +daeElementRef +domCommon_float_or_param_type::domParam::create(DAE& dae) +{ + domCommon_float_or_param_type::domParamRef ref = new domCommon_float_or_param_type::domParam(dae); + return ref; +} + + +daeMetaElement * +domCommon_float_or_param_type::domParam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "param" ); + meta->registerClass(domCommon_float_or_param_type::domParam::create); + + meta->setIsInnerClass( true ); + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domCommon_float_or_param_type::domParam , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCommon_float_or_param_type::domParam)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCommon_newparam_type.cpp b/1.4.0/dom/src/1.4/dom/domCommon_newparam_type.cpp new file mode 100644 index 0000000..93f9eba --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCommon_newparam_type.cpp @@ -0,0 +1,297 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCommon_newparam_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCommon_newparam_type::create(DAE& dae) +{ + domCommon_newparam_typeRef ref = new domCommon_newparam_type(dae); + return ref; +} + + +daeMetaElement * +domCommon_newparam_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "common_newparam_type" ); + meta->registerClass(domCommon_newparam_type::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "semantic" ); + mea->setOffset( daeOffsetOf(domCommon_newparam_type,elemSemantic) ); + mea->setElementType( domCommon_newparam_type::domSemantic::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float" ); + mea->setOffset( daeOffsetOf(domCommon_newparam_type,elemFloat) ); + mea->setElementType( domCommon_newparam_type::domFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2" ); + mea->setOffset( daeOffsetOf(domCommon_newparam_type,elemFloat2) ); + mea->setElementType( domCommon_newparam_type::domFloat2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3" ); + mea->setOffset( daeOffsetOf(domCommon_newparam_type,elemFloat3) ); + mea->setElementType( domCommon_newparam_type::domFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4" ); + mea->setOffset( daeOffsetOf(domCommon_newparam_type,elemFloat4) ); + mea->setElementType( domCommon_newparam_type::domFloat4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "surface" ); + mea->setOffset( daeOffsetOf(domCommon_newparam_type,elemSurface) ); + mea->setElementType( domFx_surface_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sampler2D" ); + mea->setOffset( daeOffsetOf(domCommon_newparam_type,elemSampler2D) ); + mea->setElementType( domFx_sampler2D_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCommon_newparam_type,_contents)); + meta->addContentsOrder(daeOffsetOf(domCommon_newparam_type,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCommon_newparam_type,_CMData), 1); + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domCommon_newparam_type , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCommon_newparam_type)); + meta->validate(); + + return meta; +} + +daeElementRef +domCommon_newparam_type::domSemantic::create(DAE& dae) +{ + domCommon_newparam_type::domSemanticRef ref = new domCommon_newparam_type::domSemantic(dae); + return ref; +} + + +daeMetaElement * +domCommon_newparam_type::domSemantic::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "semantic" ); + meta->registerClass(domCommon_newparam_type::domSemantic::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domCommon_newparam_type::domSemantic , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCommon_newparam_type::domSemantic)); + meta->validate(); + + return meta; +} + +daeElementRef +domCommon_newparam_type::domFloat::create(DAE& dae) +{ + domCommon_newparam_type::domFloatRef ref = new domCommon_newparam_type::domFloat(dae); + return ref; +} + + +daeMetaElement * +domCommon_newparam_type::domFloat::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float" ); + meta->registerClass(domCommon_newparam_type::domFloat::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domCommon_newparam_type::domFloat , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCommon_newparam_type::domFloat)); + meta->validate(); + + return meta; +} + +daeElementRef +domCommon_newparam_type::domFloat2::create(DAE& dae) +{ + domCommon_newparam_type::domFloat2Ref ref = new domCommon_newparam_type::domFloat2(dae); + return ref; +} + + +daeMetaElement * +domCommon_newparam_type::domFloat2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2" ); + meta->registerClass(domCommon_newparam_type::domFloat2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domCommon_newparam_type::domFloat2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCommon_newparam_type::domFloat2)); + meta->validate(); + + return meta; +} + +daeElementRef +domCommon_newparam_type::domFloat3::create(DAE& dae) +{ + domCommon_newparam_type::domFloat3Ref ref = new domCommon_newparam_type::domFloat3(dae); + return ref; +} + + +daeMetaElement * +domCommon_newparam_type::domFloat3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3" ); + meta->registerClass(domCommon_newparam_type::domFloat3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domCommon_newparam_type::domFloat3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCommon_newparam_type::domFloat3)); + meta->validate(); + + return meta; +} + +daeElementRef +domCommon_newparam_type::domFloat4::create(DAE& dae) +{ + domCommon_newparam_type::domFloat4Ref ref = new domCommon_newparam_type::domFloat4(dae); + return ref; +} + + +daeMetaElement * +domCommon_newparam_type::domFloat4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4" ); + meta->registerClass(domCommon_newparam_type::domFloat4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domCommon_newparam_type::domFloat4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCommon_newparam_type::domFloat4)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCommon_transparent_type.cpp b/1.4.0/dom/src/1.4/dom/domCommon_transparent_type.cpp new file mode 100644 index 0000000..f5355a2 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCommon_transparent_type.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCommon_transparent_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCommon_transparent_type::create(DAE& dae) +{ + domCommon_transparent_typeRef ref = new domCommon_transparent_type(dae); + return ref; +} + + +daeMetaElement * +domCommon_transparent_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "common_transparent_type" ); + meta->registerClass(domCommon_transparent_type::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "color" ); + mea->setOffset( daeOffsetOf(domCommon_transparent_type,elemColor) ); + mea->setElementType( domColor::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "param" ); + mea->setOffset( daeOffsetOf(domCommon_transparent_type,elemParam) ); + mea->setElementType( domParam::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texture" ); + mea->setOffset( daeOffsetOf(domCommon_transparent_type,elemTexture) ); + mea->setElementType( domTexture::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domCommon_transparent_type,_contents)); + meta->addContentsOrder(daeOffsetOf(domCommon_transparent_type,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domCommon_transparent_type,_CMData), 1); + // Add attribute: opaque + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "opaque" ); + ma->setType( dae.getAtomicTypes().get("Fx_opaque_enum")); + ma->setOffset( daeOffsetOf( domCommon_transparent_type , attrOpaque )); + ma->setContainer( meta ); + ma->setDefaultString( "A_ONE"); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCommon_transparent_type)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domConstants.cpp b/1.4.0/dom/src/1.4/dom/domConstants.cpp new file mode 100644 index 0000000..295301a --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domConstants.cpp @@ -0,0 +1,1087 @@ +/* + * Copyright 2006 Sony Computer Entertainment Inc. + * + * Licensed under the MIT Open Source License, for details please see license.txt or the website + * http://www.opensource.org/licenses/mit-license.php + * + */ + +#include <1.4/dom/domConstants.h> + +namespace ColladaDOM141 { + +DLLSPEC daeString COLLADA_VERSION = "1.4.1"; +DLLSPEC daeString COLLADA_NAMESPACE = "http://www.collada.org/2005/11/COLLADASchema"; + +DLLSPEC daeString COMMON_PROFILE_INPUT_BINORMAL = "BINORMAL"; +DLLSPEC daeString COMMON_PROFILE_INPUT_COLOR = "COLOR"; +DLLSPEC daeString COMMON_PROFILE_INPUT_CONTINUITY = "CONTINUITY"; +DLLSPEC daeString COMMON_PROFILE_INPUT_IMAGE = "IMAGE"; +DLLSPEC daeString COMMON_PROFILE_INPUT_IN_TANGENT = "IN_TANGENT"; +DLLSPEC daeString COMMON_PROFILE_INPUT_INPUT = "INPUT"; +DLLSPEC daeString COMMON_PROFILE_INPUT_INTERPOLATION = "INTERPOLATION"; +DLLSPEC daeString COMMON_PROFILE_INPUT_INV_BIND_MATRIX = "INV_BIND_MATRIX"; +DLLSPEC daeString COMMON_PROFILE_INPUT_JOINT = "JOINT"; +DLLSPEC daeString COMMON_PROFILE_INPUT_LINEAR_STEPS = "LINEAR_STEPS"; +DLLSPEC daeString COMMON_PROFILE_INPUT_MORPH_TARGET = "MORPH_TARGET"; +DLLSPEC daeString COMMON_PROFILE_INPUT_MORPH_WEIGHT = "MORPH_WEIGHT"; +DLLSPEC daeString COMMON_PROFILE_INPUT_NORMAL = "NORMAL"; +DLLSPEC daeString COMMON_PROFILE_INPUT_OUTPUT = "OUTPUT"; +DLLSPEC daeString COMMON_PROFILE_INPUT_OUT_TANGENT = "OUT_TANGENT"; +DLLSPEC daeString COMMON_PROFILE_INPUT_POSITION = "POSITION"; +DLLSPEC daeString COMMON_PROFILE_INPUT_TANGENT = "TANGENT"; +DLLSPEC daeString COMMON_PROFILE_INPUT_TEXBINORMAL = "TEXBINORMAL"; +DLLSPEC daeString COMMON_PROFILE_INPUT_TEXCOORD = "TEXCOORD"; +DLLSPEC daeString COMMON_PROFILE_INPUT_TEXTANGENT = "TEXTANGENT"; +DLLSPEC daeString COMMON_PROFILE_INPUT_UV = "UV"; +DLLSPEC daeString COMMON_PROFILE_INPUT_VERTEX = "VERTEX"; +DLLSPEC daeString COMMON_PROFILE_INPUT_WEIGHT = "WEIGHT"; + +DLLSPEC daeString COMMON_PROFILE_PARAM_A = "A"; +DLLSPEC daeString COMMON_PROFILE_PARAM_ANGLE = "ANGLE"; +DLLSPEC daeString COMMON_PROFILE_PARAM_B = "B"; +DLLSPEC daeString COMMON_PROFILE_PARAM_DOUBLE_SIDED = "DOUBLE_SIDED"; +DLLSPEC daeString COMMON_PROFILE_PARAM_G = "G"; +DLLSPEC daeString COMMON_PROFILE_PARAM_P = "P"; +DLLSPEC daeString COMMON_PROFILE_PARAM_Q = "Q"; +DLLSPEC daeString COMMON_PROFILE_PARAM_R = "R"; +DLLSPEC daeString COMMON_PROFILE_PARAM_S = "S"; +DLLSPEC daeString COMMON_PROFILE_PARAM_T = "T"; +DLLSPEC daeString COMMON_PROFILE_PARAM_TIME = "TIME"; +DLLSPEC daeString COMMON_PROFILE_PARAM_U = "U"; +DLLSPEC daeString COMMON_PROFILE_PARAM_V = "V"; +DLLSPEC daeString COMMON_PROFILE_PARAM_W = "W"; +DLLSPEC daeString COMMON_PROFILE_PARAM_X = "X"; +DLLSPEC daeString COMMON_PROFILE_PARAM_Y = "Y"; +DLLSPEC daeString COMMON_PROFILE_PARAM_Z = "Z"; + + +DLLSPEC daeString COLLADA_TYPE_INPUTGLOBAL = "InputGlobal"; +DLLSPEC daeString COLLADA_TYPE_INPUTLOCAL = "InputLocal"; +DLLSPEC daeString COLLADA_TYPE_INPUTLOCALOFFSET = "InputLocalOffset"; +DLLSPEC daeString COLLADA_TYPE_INSTANCEWITHEXTRA = "InstanceWithExtra"; +DLLSPEC daeString COLLADA_TYPE_TARGETABLEFLOAT = "TargetableFloat"; +DLLSPEC daeString COLLADA_TYPE_TARGETABLEFLOAT3 = "TargetableFloat3"; +DLLSPEC daeString COLLADA_TYPE_FX_SURFACE_FORMAT_HINT_COMMON = "fx_surface_format_hint_common"; +DLLSPEC daeString COLLADA_TYPE_CHANNELS = "channels"; +DLLSPEC daeString COLLADA_TYPE_RANGE = "range"; +DLLSPEC daeString COLLADA_TYPE_PRECISION = "precision"; +DLLSPEC daeString COLLADA_TYPE_OPTION = "option"; +DLLSPEC daeString COLLADA_TYPE_FX_SURFACE_INIT_PLANAR_COMMON = "fx_surface_init_planar_common"; +DLLSPEC daeString COLLADA_TYPE_ALL = "all"; +DLLSPEC daeString COLLADA_TYPE_FX_SURFACE_INIT_VOLUME_COMMON = "fx_surface_init_volume_common"; +DLLSPEC daeString COLLADA_TYPE_PRIMARY = "primary"; +DLLSPEC daeString COLLADA_TYPE_FX_SURFACE_INIT_CUBE_COMMON = "fx_surface_init_cube_common"; +DLLSPEC daeString COLLADA_TYPE_ORDER = "order"; +DLLSPEC daeString COLLADA_TYPE_FACE = "face"; +DLLSPEC daeString COLLADA_TYPE_FX_SURFACE_INIT_FROM_COMMON = "fx_surface_init_from_common"; +DLLSPEC daeString COLLADA_TYPE_FX_SURFACE_COMMON = "fx_surface_common"; +DLLSPEC daeString COLLADA_TYPE_FORMAT = "format"; +DLLSPEC daeString COLLADA_TYPE_SIZE = "size"; +DLLSPEC daeString COLLADA_TYPE_VIEWPORT_RATIO = "viewport_ratio"; +DLLSPEC daeString COLLADA_TYPE_MIP_LEVELS = "mip_levels"; +DLLSPEC daeString COLLADA_TYPE_MIPMAP_GENERATE = "mipmap_generate"; +DLLSPEC daeString COLLADA_TYPE_FX_SAMPLER1D_COMMON = "fx_sampler1D_common"; +DLLSPEC daeString COLLADA_TYPE_SOURCE = "source"; +DLLSPEC daeString COLLADA_TYPE_WRAP_S = "wrap_s"; +DLLSPEC daeString COLLADA_TYPE_MINFILTER = "minfilter"; +DLLSPEC daeString COLLADA_TYPE_MAGFILTER = "magfilter"; +DLLSPEC daeString COLLADA_TYPE_MIPFILTER = "mipfilter"; +DLLSPEC daeString COLLADA_TYPE_BORDER_COLOR = "border_color"; +DLLSPEC daeString COLLADA_TYPE_MIPMAP_MAXLEVEL = "mipmap_maxlevel"; +DLLSPEC daeString COLLADA_TYPE_MIPMAP_BIAS = "mipmap_bias"; +DLLSPEC daeString COLLADA_TYPE_FX_SAMPLER2D_COMMON = "fx_sampler2D_common"; +DLLSPEC daeString COLLADA_TYPE_WRAP_T = "wrap_t"; +DLLSPEC daeString COLLADA_TYPE_FX_SAMPLER3D_COMMON = "fx_sampler3D_common"; +DLLSPEC daeString COLLADA_TYPE_WRAP_P = "wrap_p"; +DLLSPEC daeString COLLADA_TYPE_FX_SAMPLERCUBE_COMMON = "fx_samplerCUBE_common"; +DLLSPEC daeString COLLADA_TYPE_FX_SAMPLERRECT_COMMON = "fx_samplerRECT_common"; +DLLSPEC daeString COLLADA_TYPE_FX_SAMPLERDEPTH_COMMON = "fx_samplerDEPTH_common"; +DLLSPEC daeString COLLADA_TYPE_FX_COLORTARGET_COMMON = "fx_colortarget_common"; +DLLSPEC daeString COLLADA_TYPE_FX_DEPTHTARGET_COMMON = "fx_depthtarget_common"; +DLLSPEC daeString COLLADA_TYPE_FX_STENCILTARGET_COMMON = "fx_stenciltarget_common"; +DLLSPEC daeString COLLADA_TYPE_FX_CLEARCOLOR_COMMON = "fx_clearcolor_common"; +DLLSPEC daeString COLLADA_TYPE_FX_CLEARDEPTH_COMMON = "fx_cleardepth_common"; +DLLSPEC daeString COLLADA_TYPE_FX_CLEARSTENCIL_COMMON = "fx_clearstencil_common"; +DLLSPEC daeString COLLADA_TYPE_FX_ANNOTATE_COMMON = "fx_annotate_common"; +DLLSPEC daeString COLLADA_TYPE_FX_INCLUDE_COMMON = "fx_include_common"; +DLLSPEC daeString COLLADA_TYPE_FX_NEWPARAM_COMMON = "fx_newparam_common"; +DLLSPEC daeString COLLADA_TYPE_SEMANTIC = "semantic"; +DLLSPEC daeString COLLADA_TYPE_MODIFIER = "modifier"; +DLLSPEC daeString COLLADA_TYPE_FX_CODE_PROFILE = "fx_code_profile"; +DLLSPEC daeString COLLADA_TYPE_GL_SAMPLER1D = "gl_sampler1D"; +DLLSPEC daeString COLLADA_TYPE_GL_SAMPLER2D = "gl_sampler2D"; +DLLSPEC daeString COLLADA_TYPE_GL_SAMPLER3D = "gl_sampler3D"; +DLLSPEC daeString COLLADA_TYPE_GL_SAMPLERCUBE = "gl_samplerCUBE"; +DLLSPEC daeString COLLADA_TYPE_GL_SAMPLERRECT = "gl_samplerRECT"; +DLLSPEC daeString COLLADA_TYPE_GL_SAMPLERDEPTH = "gl_samplerDEPTH"; +DLLSPEC daeString COLLADA_TYPE_GLSL_NEWARRAY_TYPE = "glsl_newarray_type"; +DLLSPEC daeString COLLADA_TYPE_GLSL_SETARRAY_TYPE = "glsl_setarray_type"; +DLLSPEC daeString COLLADA_TYPE_GLSL_SURFACE_TYPE = "glsl_surface_type"; +DLLSPEC daeString COLLADA_TYPE_GENERATOR = "generator"; +DLLSPEC daeString COLLADA_TYPE_NAME = "name"; +DLLSPEC daeString COLLADA_TYPE_GLSL_NEWPARAM = "glsl_newparam"; +DLLSPEC daeString COLLADA_TYPE_GLSL_SETPARAM_SIMPLE = "glsl_setparam_simple"; +DLLSPEC daeString COLLADA_TYPE_GLSL_SETPARAM = "glsl_setparam"; +DLLSPEC daeString COLLADA_TYPE_COMMON_FLOAT_OR_PARAM_TYPE = "common_float_or_param_type"; +DLLSPEC daeString COLLADA_TYPE_FLOAT = "float"; +DLLSPEC daeString COLLADA_TYPE_PARAM = "param"; +DLLSPEC daeString COLLADA_TYPE_COMMON_COLOR_OR_TEXTURE_TYPE = "common_color_or_texture_type"; +DLLSPEC daeString COLLADA_TYPE_COLOR = "color"; +DLLSPEC daeString COLLADA_TYPE_TEXTURE = "texture"; +DLLSPEC daeString COLLADA_TYPE_COMMON_TRANSPARENT_TYPE = "common_transparent_type"; +DLLSPEC daeString COLLADA_TYPE_COMMON_NEWPARAM_TYPE = "common_newparam_type"; +DLLSPEC daeString COLLADA_TYPE_FLOAT2 = "float2"; +DLLSPEC daeString COLLADA_TYPE_FLOAT3 = "float3"; +DLLSPEC daeString COLLADA_TYPE_FLOAT4 = "float4"; +DLLSPEC daeString COLLADA_TYPE_CG_SAMPLER1D = "cg_sampler1D"; +DLLSPEC daeString COLLADA_TYPE_CG_SAMPLER2D = "cg_sampler2D"; +DLLSPEC daeString COLLADA_TYPE_CG_SAMPLER3D = "cg_sampler3D"; +DLLSPEC daeString COLLADA_TYPE_CG_SAMPLERCUBE = "cg_samplerCUBE"; +DLLSPEC daeString COLLADA_TYPE_CG_SAMPLERRECT = "cg_samplerRECT"; +DLLSPEC daeString COLLADA_TYPE_CG_SAMPLERDEPTH = "cg_samplerDEPTH"; +DLLSPEC daeString COLLADA_TYPE_CG_CONNECT_PARAM = "cg_connect_param"; +DLLSPEC daeString COLLADA_TYPE_CG_NEWARRAY_TYPE = "cg_newarray_type"; +DLLSPEC daeString COLLADA_TYPE_CG_SETARRAY_TYPE = "cg_setarray_type"; +DLLSPEC daeString COLLADA_TYPE_CG_SETUSER_TYPE = "cg_setuser_type"; +DLLSPEC daeString COLLADA_TYPE_CG_SURFACE_TYPE = "cg_surface_type"; +DLLSPEC daeString COLLADA_TYPE_CG_NEWPARAM = "cg_newparam"; +DLLSPEC daeString COLLADA_TYPE_CG_SETPARAM_SIMPLE = "cg_setparam_simple"; +DLLSPEC daeString COLLADA_TYPE_CG_SETPARAM = "cg_setparam"; +DLLSPEC daeString COLLADA_TYPE_GLES_TEXTURE_CONSTANT_TYPE = "gles_texture_constant_type"; +DLLSPEC daeString COLLADA_TYPE_GLES_TEXENV_COMMAND_TYPE = "gles_texenv_command_type"; +DLLSPEC daeString COLLADA_TYPE_GLES_TEXCOMBINER_ARGUMENTRGB_TYPE = "gles_texcombiner_argumentRGB_type"; +DLLSPEC daeString COLLADA_TYPE_GLES_TEXCOMBINER_ARGUMENTALPHA_TYPE = "gles_texcombiner_argumentAlpha_type"; +DLLSPEC daeString COLLADA_TYPE_GLES_TEXCOMBINER_COMMANDRGB_TYPE = "gles_texcombiner_commandRGB_type"; +DLLSPEC daeString COLLADA_TYPE_GLES_TEXCOMBINER_COMMANDALPHA_TYPE = "gles_texcombiner_commandAlpha_type"; +DLLSPEC daeString COLLADA_TYPE_GLES_TEXCOMBINER_COMMAND_TYPE = "gles_texcombiner_command_type"; +DLLSPEC daeString COLLADA_TYPE_GLES_TEXTURE_PIPELINE = "gles_texture_pipeline"; +DLLSPEC daeString COLLADA_TYPE_GLES_TEXTURE_UNIT = "gles_texture_unit"; +DLLSPEC daeString COLLADA_TYPE_SURFACE = "surface"; +DLLSPEC daeString COLLADA_TYPE_SAMPLER_STATE = "sampler_state"; +DLLSPEC daeString COLLADA_TYPE_TEXCOORD = "texcoord"; +DLLSPEC daeString COLLADA_TYPE_GLES_SAMPLER_STATE = "gles_sampler_state"; +DLLSPEC daeString COLLADA_TYPE_GLES_NEWPARAM = "gles_newparam"; +DLLSPEC daeString COLLADA_TYPE_FX_SURFACE_INIT_COMMON = "fx_surface_init_common"; +DLLSPEC daeString COLLADA_TYPE_INIT_AS_NULL = "init_as_null"; +DLLSPEC daeString COLLADA_TYPE_INIT_AS_TARGET = "init_as_target"; +DLLSPEC daeString COLLADA_TYPE_FX_ANNOTATE_TYPE_COMMON = "fx_annotate_type_common"; +DLLSPEC daeString COLLADA_TYPE_BOOL = "bool"; +DLLSPEC daeString COLLADA_TYPE_BOOL2 = "bool2"; +DLLSPEC daeString COLLADA_TYPE_BOOL3 = "bool3"; +DLLSPEC daeString COLLADA_TYPE_BOOL4 = "bool4"; +DLLSPEC daeString COLLADA_TYPE_INT = "int"; +DLLSPEC daeString COLLADA_TYPE_INT2 = "int2"; +DLLSPEC daeString COLLADA_TYPE_INT3 = "int3"; +DLLSPEC daeString COLLADA_TYPE_INT4 = "int4"; +DLLSPEC daeString COLLADA_TYPE_FLOAT2X2 = "float2x2"; +DLLSPEC daeString COLLADA_TYPE_FLOAT3X3 = "float3x3"; +DLLSPEC daeString COLLADA_TYPE_FLOAT4X4 = "float4x4"; +DLLSPEC daeString COLLADA_TYPE_STRING = "string"; +DLLSPEC daeString COLLADA_TYPE_FX_BASIC_TYPE_COMMON = "fx_basic_type_common"; +DLLSPEC daeString COLLADA_TYPE_FLOAT1X1 = "float1x1"; +DLLSPEC daeString COLLADA_TYPE_FLOAT1X2 = "float1x2"; +DLLSPEC daeString COLLADA_TYPE_FLOAT1X3 = "float1x3"; +DLLSPEC daeString COLLADA_TYPE_FLOAT1X4 = "float1x4"; +DLLSPEC daeString COLLADA_TYPE_FLOAT2X1 = "float2x1"; +DLLSPEC daeString COLLADA_TYPE_FLOAT2X3 = "float2x3"; +DLLSPEC daeString COLLADA_TYPE_FLOAT2X4 = "float2x4"; +DLLSPEC daeString COLLADA_TYPE_FLOAT3X1 = "float3x1"; +DLLSPEC daeString COLLADA_TYPE_FLOAT3X2 = "float3x2"; +DLLSPEC daeString COLLADA_TYPE_FLOAT3X4 = "float3x4"; +DLLSPEC daeString COLLADA_TYPE_FLOAT4X1 = "float4x1"; +DLLSPEC daeString COLLADA_TYPE_FLOAT4X2 = "float4x2"; +DLLSPEC daeString COLLADA_TYPE_FLOAT4X3 = "float4x3"; +DLLSPEC daeString COLLADA_TYPE_ENUM = "enum"; +DLLSPEC daeString COLLADA_TYPE_GL_PIPELINE_SETTINGS = "gl_pipeline_settings"; +DLLSPEC daeString COLLADA_TYPE_ALPHA_FUNC = "alpha_func"; +DLLSPEC daeString COLLADA_TYPE_FUNC = "func"; +DLLSPEC daeString COLLADA_TYPE_VALUE = "value"; +DLLSPEC daeString COLLADA_TYPE_BLEND_FUNC = "blend_func"; +DLLSPEC daeString COLLADA_TYPE_SRC = "src"; +DLLSPEC daeString COLLADA_TYPE_DEST = "dest"; +DLLSPEC daeString COLLADA_TYPE_BLEND_FUNC_SEPARATE = "blend_func_separate"; +DLLSPEC daeString COLLADA_TYPE_SRC_RGB = "src_rgb"; +DLLSPEC daeString COLLADA_TYPE_DEST_RGB = "dest_rgb"; +DLLSPEC daeString COLLADA_TYPE_SRC_ALPHA = "src_alpha"; +DLLSPEC daeString COLLADA_TYPE_DEST_ALPHA = "dest_alpha"; +DLLSPEC daeString COLLADA_TYPE_BLEND_EQUATION = "blend_equation"; +DLLSPEC daeString COLLADA_TYPE_BLEND_EQUATION_SEPARATE = "blend_equation_separate"; +DLLSPEC daeString COLLADA_TYPE_RGB = "rgb"; +DLLSPEC daeString COLLADA_TYPE_ALPHA = "alpha"; +DLLSPEC daeString COLLADA_TYPE_COLOR_MATERIAL = "color_material"; +DLLSPEC daeString COLLADA_TYPE_MODE = "mode"; +DLLSPEC daeString COLLADA_TYPE_CULL_FACE = "cull_face"; +DLLSPEC daeString COLLADA_TYPE_DEPTH_FUNC = "depth_func"; +DLLSPEC daeString COLLADA_TYPE_FOG_MODE = "fog_mode"; +DLLSPEC daeString COLLADA_TYPE_FOG_COORD_SRC = "fog_coord_src"; +DLLSPEC daeString COLLADA_TYPE_FRONT_FACE = "front_face"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_MODEL_COLOR_CONTROL = "light_model_color_control"; +DLLSPEC daeString COLLADA_TYPE_LOGIC_OP = "logic_op"; +DLLSPEC daeString COLLADA_TYPE_POLYGON_MODE = "polygon_mode"; +DLLSPEC daeString COLLADA_TYPE_SHADE_MODEL = "shade_model"; +DLLSPEC daeString COLLADA_TYPE_STENCIL_FUNC = "stencil_func"; +DLLSPEC daeString COLLADA_TYPE_REF = "ref"; +DLLSPEC daeString COLLADA_TYPE_MASK = "mask"; +DLLSPEC daeString COLLADA_TYPE_STENCIL_OP = "stencil_op"; +DLLSPEC daeString COLLADA_TYPE_FAIL = "fail"; +DLLSPEC daeString COLLADA_TYPE_ZFAIL = "zfail"; +DLLSPEC daeString COLLADA_TYPE_ZPASS = "zpass"; +DLLSPEC daeString COLLADA_TYPE_STENCIL_FUNC_SEPARATE = "stencil_func_separate"; +DLLSPEC daeString COLLADA_TYPE_FRONT = "front"; +DLLSPEC daeString COLLADA_TYPE_BACK = "back"; +DLLSPEC daeString COLLADA_TYPE_STENCIL_OP_SEPARATE = "stencil_op_separate"; +DLLSPEC daeString COLLADA_TYPE_STENCIL_MASK_SEPARATE = "stencil_mask_separate"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_ENABLE = "light_enable"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_AMBIENT = "light_ambient"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_DIFFUSE = "light_diffuse"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_SPECULAR = "light_specular"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_POSITION = "light_position"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_CONSTANT_ATTENUATION = "light_constant_attenuation"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_LINEAR_ATTENUATION = "light_linear_attenuation"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_QUADRATIC_ATTENUATION = "light_quadratic_attenuation"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_SPOT_CUTOFF = "light_spot_cutoff"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_SPOT_DIRECTION = "light_spot_direction"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_SPOT_EXPONENT = "light_spot_exponent"; +DLLSPEC daeString COLLADA_TYPE_TEXTURE1D = "texture1D"; +DLLSPEC daeString COLLADA_TYPE_TEXTURE2D = "texture2D"; +DLLSPEC daeString COLLADA_TYPE_TEXTURE3D = "texture3D"; +DLLSPEC daeString COLLADA_TYPE_TEXTURECUBE = "textureCUBE"; +DLLSPEC daeString COLLADA_TYPE_TEXTURERECT = "textureRECT"; +DLLSPEC daeString COLLADA_TYPE_TEXTUREDEPTH = "textureDEPTH"; +DLLSPEC daeString COLLADA_TYPE_TEXTURE1D_ENABLE = "texture1D_enable"; +DLLSPEC daeString COLLADA_TYPE_TEXTURE2D_ENABLE = "texture2D_enable"; +DLLSPEC daeString COLLADA_TYPE_TEXTURE3D_ENABLE = "texture3D_enable"; +DLLSPEC daeString COLLADA_TYPE_TEXTURECUBE_ENABLE = "textureCUBE_enable"; +DLLSPEC daeString COLLADA_TYPE_TEXTURERECT_ENABLE = "textureRECT_enable"; +DLLSPEC daeString COLLADA_TYPE_TEXTUREDEPTH_ENABLE = "textureDEPTH_enable"; +DLLSPEC daeString COLLADA_TYPE_TEXTURE_ENV_COLOR = "texture_env_color"; +DLLSPEC daeString COLLADA_TYPE_TEXTURE_ENV_MODE = "texture_env_mode"; +DLLSPEC daeString COLLADA_TYPE_CLIP_PLANE = "clip_plane"; +DLLSPEC daeString COLLADA_TYPE_CLIP_PLANE_ENABLE = "clip_plane_enable"; +DLLSPEC daeString COLLADA_TYPE_BLEND_COLOR = "blend_color"; +DLLSPEC daeString COLLADA_TYPE_CLEAR_COLOR = "clear_color"; +DLLSPEC daeString COLLADA_TYPE_CLEAR_STENCIL = "clear_stencil"; +DLLSPEC daeString COLLADA_TYPE_CLEAR_DEPTH = "clear_depth"; +DLLSPEC daeString COLLADA_TYPE_COLOR_MASK = "color_mask"; +DLLSPEC daeString COLLADA_TYPE_DEPTH_BOUNDS = "depth_bounds"; +DLLSPEC daeString COLLADA_TYPE_DEPTH_MASK = "depth_mask"; +DLLSPEC daeString COLLADA_TYPE_DEPTH_RANGE = "depth_range"; +DLLSPEC daeString COLLADA_TYPE_FOG_DENSITY = "fog_density"; +DLLSPEC daeString COLLADA_TYPE_FOG_START = "fog_start"; +DLLSPEC daeString COLLADA_TYPE_FOG_END = "fog_end"; +DLLSPEC daeString COLLADA_TYPE_FOG_COLOR = "fog_color"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_MODEL_AMBIENT = "light_model_ambient"; +DLLSPEC daeString COLLADA_TYPE_LIGHTING_ENABLE = "lighting_enable"; +DLLSPEC daeString COLLADA_TYPE_LINE_STIPPLE = "line_stipple"; +DLLSPEC daeString COLLADA_TYPE_LINE_WIDTH = "line_width"; +DLLSPEC daeString COLLADA_TYPE_MATERIAL_AMBIENT = "material_ambient"; +DLLSPEC daeString COLLADA_TYPE_MATERIAL_DIFFUSE = "material_diffuse"; +DLLSPEC daeString COLLADA_TYPE_MATERIAL_EMISSION = "material_emission"; +DLLSPEC daeString COLLADA_TYPE_MATERIAL_SHININESS = "material_shininess"; +DLLSPEC daeString COLLADA_TYPE_MATERIAL_SPECULAR = "material_specular"; +DLLSPEC daeString COLLADA_TYPE_MODEL_VIEW_MATRIX = "model_view_matrix"; +DLLSPEC daeString COLLADA_TYPE_POINT_DISTANCE_ATTENUATION = "point_distance_attenuation"; +DLLSPEC daeString COLLADA_TYPE_POINT_FADE_THRESHOLD_SIZE = "point_fade_threshold_size"; +DLLSPEC daeString COLLADA_TYPE_POINT_SIZE = "point_size"; +DLLSPEC daeString COLLADA_TYPE_POINT_SIZE_MIN = "point_size_min"; +DLLSPEC daeString COLLADA_TYPE_POINT_SIZE_MAX = "point_size_max"; +DLLSPEC daeString COLLADA_TYPE_POLYGON_OFFSET = "polygon_offset"; +DLLSPEC daeString COLLADA_TYPE_PROJECTION_MATRIX = "projection_matrix"; +DLLSPEC daeString COLLADA_TYPE_SCISSOR = "scissor"; +DLLSPEC daeString COLLADA_TYPE_STENCIL_MASK = "stencil_mask"; +DLLSPEC daeString COLLADA_TYPE_ALPHA_TEST_ENABLE = "alpha_test_enable"; +DLLSPEC daeString COLLADA_TYPE_AUTO_NORMAL_ENABLE = "auto_normal_enable"; +DLLSPEC daeString COLLADA_TYPE_BLEND_ENABLE = "blend_enable"; +DLLSPEC daeString COLLADA_TYPE_COLOR_LOGIC_OP_ENABLE = "color_logic_op_enable"; +DLLSPEC daeString COLLADA_TYPE_COLOR_MATERIAL_ENABLE = "color_material_enable"; +DLLSPEC daeString COLLADA_TYPE_CULL_FACE_ENABLE = "cull_face_enable"; +DLLSPEC daeString COLLADA_TYPE_DEPTH_BOUNDS_ENABLE = "depth_bounds_enable"; +DLLSPEC daeString COLLADA_TYPE_DEPTH_CLAMP_ENABLE = "depth_clamp_enable"; +DLLSPEC daeString COLLADA_TYPE_DEPTH_TEST_ENABLE = "depth_test_enable"; +DLLSPEC daeString COLLADA_TYPE_DITHER_ENABLE = "dither_enable"; +DLLSPEC daeString COLLADA_TYPE_FOG_ENABLE = "fog_enable"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_MODEL_LOCAL_VIEWER_ENABLE = "light_model_local_viewer_enable"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_MODEL_TWO_SIDE_ENABLE = "light_model_two_side_enable"; +DLLSPEC daeString COLLADA_TYPE_LINE_SMOOTH_ENABLE = "line_smooth_enable"; +DLLSPEC daeString COLLADA_TYPE_LINE_STIPPLE_ENABLE = "line_stipple_enable"; +DLLSPEC daeString COLLADA_TYPE_LOGIC_OP_ENABLE = "logic_op_enable"; +DLLSPEC daeString COLLADA_TYPE_MULTISAMPLE_ENABLE = "multisample_enable"; +DLLSPEC daeString COLLADA_TYPE_NORMALIZE_ENABLE = "normalize_enable"; +DLLSPEC daeString COLLADA_TYPE_POINT_SMOOTH_ENABLE = "point_smooth_enable"; +DLLSPEC daeString COLLADA_TYPE_POLYGON_OFFSET_FILL_ENABLE = "polygon_offset_fill_enable"; +DLLSPEC daeString COLLADA_TYPE_POLYGON_OFFSET_LINE_ENABLE = "polygon_offset_line_enable"; +DLLSPEC daeString COLLADA_TYPE_POLYGON_OFFSET_POINT_ENABLE = "polygon_offset_point_enable"; +DLLSPEC daeString COLLADA_TYPE_POLYGON_SMOOTH_ENABLE = "polygon_smooth_enable"; +DLLSPEC daeString COLLADA_TYPE_POLYGON_STIPPLE_ENABLE = "polygon_stipple_enable"; +DLLSPEC daeString COLLADA_TYPE_RESCALE_NORMAL_ENABLE = "rescale_normal_enable"; +DLLSPEC daeString COLLADA_TYPE_SAMPLE_ALPHA_TO_COVERAGE_ENABLE = "sample_alpha_to_coverage_enable"; +DLLSPEC daeString COLLADA_TYPE_SAMPLE_ALPHA_TO_ONE_ENABLE = "sample_alpha_to_one_enable"; +DLLSPEC daeString COLLADA_TYPE_SAMPLE_COVERAGE_ENABLE = "sample_coverage_enable"; +DLLSPEC daeString COLLADA_TYPE_SCISSOR_TEST_ENABLE = "scissor_test_enable"; +DLLSPEC daeString COLLADA_TYPE_STENCIL_TEST_ENABLE = "stencil_test_enable"; +DLLSPEC daeString COLLADA_TYPE_GLSL_PARAM_TYPE = "glsl_param_type"; +DLLSPEC daeString COLLADA_TYPE_CG_PARAM_TYPE = "cg_param_type"; +DLLSPEC daeString COLLADA_TYPE_BOOL1 = "bool1"; +DLLSPEC daeString COLLADA_TYPE_BOOL1X1 = "bool1x1"; +DLLSPEC daeString COLLADA_TYPE_BOOL1X2 = "bool1x2"; +DLLSPEC daeString COLLADA_TYPE_BOOL1X3 = "bool1x3"; +DLLSPEC daeString COLLADA_TYPE_BOOL1X4 = "bool1x4"; +DLLSPEC daeString COLLADA_TYPE_BOOL2X1 = "bool2x1"; +DLLSPEC daeString COLLADA_TYPE_BOOL2X2 = "bool2x2"; +DLLSPEC daeString COLLADA_TYPE_BOOL2X3 = "bool2x3"; +DLLSPEC daeString COLLADA_TYPE_BOOL2X4 = "bool2x4"; +DLLSPEC daeString COLLADA_TYPE_BOOL3X1 = "bool3x1"; +DLLSPEC daeString COLLADA_TYPE_BOOL3X2 = "bool3x2"; +DLLSPEC daeString COLLADA_TYPE_BOOL3X3 = "bool3x3"; +DLLSPEC daeString COLLADA_TYPE_BOOL3X4 = "bool3x4"; +DLLSPEC daeString COLLADA_TYPE_BOOL4X1 = "bool4x1"; +DLLSPEC daeString COLLADA_TYPE_BOOL4X2 = "bool4x2"; +DLLSPEC daeString COLLADA_TYPE_BOOL4X3 = "bool4x3"; +DLLSPEC daeString COLLADA_TYPE_BOOL4X4 = "bool4x4"; +DLLSPEC daeString COLLADA_TYPE_FLOAT1 = "float1"; +DLLSPEC daeString COLLADA_TYPE_INT1 = "int1"; +DLLSPEC daeString COLLADA_TYPE_INT1X1 = "int1x1"; +DLLSPEC daeString COLLADA_TYPE_INT1X2 = "int1x2"; +DLLSPEC daeString COLLADA_TYPE_INT1X3 = "int1x3"; +DLLSPEC daeString COLLADA_TYPE_INT1X4 = "int1x4"; +DLLSPEC daeString COLLADA_TYPE_INT2X1 = "int2x1"; +DLLSPEC daeString COLLADA_TYPE_INT2X2 = "int2x2"; +DLLSPEC daeString COLLADA_TYPE_INT2X3 = "int2x3"; +DLLSPEC daeString COLLADA_TYPE_INT2X4 = "int2x4"; +DLLSPEC daeString COLLADA_TYPE_INT3X1 = "int3x1"; +DLLSPEC daeString COLLADA_TYPE_INT3X2 = "int3x2"; +DLLSPEC daeString COLLADA_TYPE_INT3X3 = "int3x3"; +DLLSPEC daeString COLLADA_TYPE_INT3X4 = "int3x4"; +DLLSPEC daeString COLLADA_TYPE_INT4X1 = "int4x1"; +DLLSPEC daeString COLLADA_TYPE_INT4X2 = "int4x2"; +DLLSPEC daeString COLLADA_TYPE_INT4X3 = "int4x3"; +DLLSPEC daeString COLLADA_TYPE_INT4X4 = "int4x4"; +DLLSPEC daeString COLLADA_TYPE_HALF = "half"; +DLLSPEC daeString COLLADA_TYPE_HALF1 = "half1"; +DLLSPEC daeString COLLADA_TYPE_HALF2 = "half2"; +DLLSPEC daeString COLLADA_TYPE_HALF3 = "half3"; +DLLSPEC daeString COLLADA_TYPE_HALF4 = "half4"; +DLLSPEC daeString COLLADA_TYPE_HALF1X1 = "half1x1"; +DLLSPEC daeString COLLADA_TYPE_HALF1X2 = "half1x2"; +DLLSPEC daeString COLLADA_TYPE_HALF1X3 = "half1x3"; +DLLSPEC daeString COLLADA_TYPE_HALF1X4 = "half1x4"; +DLLSPEC daeString COLLADA_TYPE_HALF2X1 = "half2x1"; +DLLSPEC daeString COLLADA_TYPE_HALF2X2 = "half2x2"; +DLLSPEC daeString COLLADA_TYPE_HALF2X3 = "half2x3"; +DLLSPEC daeString COLLADA_TYPE_HALF2X4 = "half2x4"; +DLLSPEC daeString COLLADA_TYPE_HALF3X1 = "half3x1"; +DLLSPEC daeString COLLADA_TYPE_HALF3X2 = "half3x2"; +DLLSPEC daeString COLLADA_TYPE_HALF3X3 = "half3x3"; +DLLSPEC daeString COLLADA_TYPE_HALF3X4 = "half3x4"; +DLLSPEC daeString COLLADA_TYPE_HALF4X1 = "half4x1"; +DLLSPEC daeString COLLADA_TYPE_HALF4X2 = "half4x2"; +DLLSPEC daeString COLLADA_TYPE_HALF4X3 = "half4x3"; +DLLSPEC daeString COLLADA_TYPE_HALF4X4 = "half4x4"; +DLLSPEC daeString COLLADA_TYPE_FIXED = "fixed"; +DLLSPEC daeString COLLADA_TYPE_FIXED1 = "fixed1"; +DLLSPEC daeString COLLADA_TYPE_FIXED2 = "fixed2"; +DLLSPEC daeString COLLADA_TYPE_FIXED3 = "fixed3"; +DLLSPEC daeString COLLADA_TYPE_FIXED4 = "fixed4"; +DLLSPEC daeString COLLADA_TYPE_FIXED1X1 = "fixed1x1"; +DLLSPEC daeString COLLADA_TYPE_FIXED1X2 = "fixed1x2"; +DLLSPEC daeString COLLADA_TYPE_FIXED1X3 = "fixed1x3"; +DLLSPEC daeString COLLADA_TYPE_FIXED1X4 = "fixed1x4"; +DLLSPEC daeString COLLADA_TYPE_FIXED2X1 = "fixed2x1"; +DLLSPEC daeString COLLADA_TYPE_FIXED2X2 = "fixed2x2"; +DLLSPEC daeString COLLADA_TYPE_FIXED2X3 = "fixed2x3"; +DLLSPEC daeString COLLADA_TYPE_FIXED2X4 = "fixed2x4"; +DLLSPEC daeString COLLADA_TYPE_FIXED3X1 = "fixed3x1"; +DLLSPEC daeString COLLADA_TYPE_FIXED3X2 = "fixed3x2"; +DLLSPEC daeString COLLADA_TYPE_FIXED3X3 = "fixed3x3"; +DLLSPEC daeString COLLADA_TYPE_FIXED3X4 = "fixed3x4"; +DLLSPEC daeString COLLADA_TYPE_FIXED4X1 = "fixed4x1"; +DLLSPEC daeString COLLADA_TYPE_FIXED4X2 = "fixed4x2"; +DLLSPEC daeString COLLADA_TYPE_FIXED4X3 = "fixed4x3"; +DLLSPEC daeString COLLADA_TYPE_FIXED4X4 = "fixed4x4"; +DLLSPEC daeString COLLADA_TYPE_GLES_PIPELINE_SETTINGS = "gles_pipeline_settings"; +DLLSPEC daeString COLLADA_TYPE_TEXTURE_PIPELINE = "texture_pipeline"; +DLLSPEC daeString COLLADA_TYPE_LIGHT_LINEAR_ATTENUTATION = "light_linear_attenutation"; +DLLSPEC daeString COLLADA_TYPE_TEXTURE_PIPELINE_ENABLE = "texture_pipeline_enable"; +DLLSPEC daeString COLLADA_TYPE_GLES_BASIC_TYPE_COMMON = "gles_basic_type_common"; +DLLSPEC daeString COLLADA_TYPE_COLLADA = "COLLADA"; +DLLSPEC daeString COLLADA_TYPE_SCENE = "scene"; +DLLSPEC daeString COLLADA_TYPE_IDREF_ARRAY = "IDREF_array"; +DLLSPEC daeString COLLADA_TYPE_NAME_ARRAY = "Name_array"; +DLLSPEC daeString COLLADA_TYPE_BOOL_ARRAY = "bool_array"; +DLLSPEC daeString COLLADA_TYPE_FLOAT_ARRAY = "float_array"; +DLLSPEC daeString COLLADA_TYPE_INT_ARRAY = "int_array"; +DLLSPEC daeString COLLADA_TYPE_ACCESSOR = "accessor"; +DLLSPEC daeString COLLADA_TYPE_TECHNIQUE_COMMON = "technique_common"; +DLLSPEC daeString COLLADA_TYPE_GEOMETRY = "geometry"; +DLLSPEC daeString COLLADA_TYPE_MESH = "mesh"; +DLLSPEC daeString COLLADA_TYPE_SPLINE = "spline"; +DLLSPEC daeString COLLADA_TYPE_CONTROL_VERTICES = "control_vertices"; +DLLSPEC daeString COLLADA_TYPE_P = "p"; +DLLSPEC daeString COLLADA_TYPE_LINES = "lines"; +DLLSPEC daeString COLLADA_TYPE_LINESTRIPS = "linestrips"; +DLLSPEC daeString COLLADA_TYPE_POLYGONS = "polygons"; +DLLSPEC daeString COLLADA_TYPE_PH = "ph"; +DLLSPEC daeString COLLADA_TYPE_H = "h"; +DLLSPEC daeString COLLADA_TYPE_POLYLIST = "polylist"; +DLLSPEC daeString COLLADA_TYPE_VCOUNT = "vcount"; +DLLSPEC daeString COLLADA_TYPE_TRIANGLES = "triangles"; +DLLSPEC daeString COLLADA_TYPE_TRIFANS = "trifans"; +DLLSPEC daeString COLLADA_TYPE_TRISTRIPS = "tristrips"; +DLLSPEC daeString COLLADA_TYPE_VERTICES = "vertices"; +DLLSPEC daeString COLLADA_TYPE_LOOKAT = "lookat"; +DLLSPEC daeString COLLADA_TYPE_MATRIX = "matrix"; +DLLSPEC daeString COLLADA_TYPE_ROTATE = "rotate"; +DLLSPEC daeString COLLADA_TYPE_SCALE = "scale"; +DLLSPEC daeString COLLADA_TYPE_SKEW = "skew"; +DLLSPEC daeString COLLADA_TYPE_TRANSLATE = "translate"; +DLLSPEC daeString COLLADA_TYPE_IMAGE = "image"; +DLLSPEC daeString COLLADA_TYPE_DATA = "data"; +DLLSPEC daeString COLLADA_TYPE_INIT_FROM = "init_from"; +DLLSPEC daeString COLLADA_TYPE_LIGHT = "light"; +DLLSPEC daeString COLLADA_TYPE_AMBIENT = "ambient"; +DLLSPEC daeString COLLADA_TYPE_DIRECTIONAL = "directional"; +DLLSPEC daeString COLLADA_TYPE_POINT = "point"; +DLLSPEC daeString COLLADA_TYPE_SPOT = "spot"; +DLLSPEC daeString COLLADA_TYPE_MATERIAL = "material"; +DLLSPEC daeString COLLADA_TYPE_CAMERA = "camera"; +DLLSPEC daeString COLLADA_TYPE_OPTICS = "optics"; +DLLSPEC daeString COLLADA_TYPE_ORTHOGRAPHIC = "orthographic"; +DLLSPEC daeString COLLADA_TYPE_PERSPECTIVE = "perspective"; +DLLSPEC daeString COLLADA_TYPE_IMAGER = "imager"; +DLLSPEC daeString COLLADA_TYPE_ANIMATION = "animation"; +DLLSPEC daeString COLLADA_TYPE_ANIMATION_CLIP = "animation_clip"; +DLLSPEC daeString COLLADA_TYPE_CHANNEL = "channel"; +DLLSPEC daeString COLLADA_TYPE_SAMPLER = "sampler"; +DLLSPEC daeString COLLADA_TYPE_CONTROLLER = "controller"; +DLLSPEC daeString COLLADA_TYPE_SKIN = "skin"; +DLLSPEC daeString COLLADA_TYPE_BIND_SHAPE_MATRIX = "bind_shape_matrix"; +DLLSPEC daeString COLLADA_TYPE_JOINTS = "joints"; +DLLSPEC daeString COLLADA_TYPE_VERTEX_WEIGHTS = "vertex_weights"; +DLLSPEC daeString COLLADA_TYPE_V = "v"; +DLLSPEC daeString COLLADA_TYPE_MORPH = "morph"; +DLLSPEC daeString COLLADA_TYPE_TARGETS = "targets"; +DLLSPEC daeString COLLADA_TYPE_ASSET = "asset"; +DLLSPEC daeString COLLADA_TYPE_CONTRIBUTOR = "contributor"; +DLLSPEC daeString COLLADA_TYPE_AUTHOR = "author"; +DLLSPEC daeString COLLADA_TYPE_AUTHORING_TOOL = "authoring_tool"; +DLLSPEC daeString COLLADA_TYPE_COMMENTS = "comments"; +DLLSPEC daeString COLLADA_TYPE_COPYRIGHT = "copyright"; +DLLSPEC daeString COLLADA_TYPE_SOURCE_DATA = "source_data"; +DLLSPEC daeString COLLADA_TYPE_CREATED = "created"; +DLLSPEC daeString COLLADA_TYPE_KEYWORDS = "keywords"; +DLLSPEC daeString COLLADA_TYPE_MODIFIED = "modified"; +DLLSPEC daeString COLLADA_TYPE_REVISION = "revision"; +DLLSPEC daeString COLLADA_TYPE_SUBJECT = "subject"; +DLLSPEC daeString COLLADA_TYPE_TITLE = "title"; +DLLSPEC daeString COLLADA_TYPE_UNIT = "unit"; +DLLSPEC daeString COLLADA_TYPE_UP_AXIS = "up_axis"; +DLLSPEC daeString COLLADA_TYPE_EXTRA = "extra"; +DLLSPEC daeString COLLADA_TYPE_TECHNIQUE = "technique"; +DLLSPEC daeString COLLADA_TYPE_NODE = "node"; +DLLSPEC daeString COLLADA_TYPE_VISUAL_SCENE = "visual_scene"; +DLLSPEC daeString COLLADA_TYPE_EVALUATE_SCENE = "evaluate_scene"; +DLLSPEC daeString COLLADA_TYPE_RENDER = "render"; +DLLSPEC daeString COLLADA_TYPE_LAYER = "layer"; +DLLSPEC daeString COLLADA_TYPE_BIND_MATERIAL = "bind_material"; +DLLSPEC daeString COLLADA_TYPE_INSTANCE_CAMERA = "instance_camera"; +DLLSPEC daeString COLLADA_TYPE_INSTANCE_CONTROLLER = "instance_controller"; +DLLSPEC daeString COLLADA_TYPE_SKELETON = "skeleton"; +DLLSPEC daeString COLLADA_TYPE_INSTANCE_EFFECT = "instance_effect"; +DLLSPEC daeString COLLADA_TYPE_TECHNIQUE_HINT = "technique_hint"; +DLLSPEC daeString COLLADA_TYPE_SETPARAM = "setparam"; +DLLSPEC daeString COLLADA_TYPE_INSTANCE_FORCE_FIELD = "instance_force_field"; +DLLSPEC daeString COLLADA_TYPE_INSTANCE_GEOMETRY = "instance_geometry"; +DLLSPEC daeString COLLADA_TYPE_INSTANCE_LIGHT = "instance_light"; +DLLSPEC daeString COLLADA_TYPE_INSTANCE_MATERIAL = "instance_material"; +DLLSPEC daeString COLLADA_TYPE_BIND = "bind"; +DLLSPEC daeString COLLADA_TYPE_BIND_VERTEX_INPUT = "bind_vertex_input"; +DLLSPEC daeString COLLADA_TYPE_INSTANCE_NODE = "instance_node"; +DLLSPEC daeString COLLADA_TYPE_INSTANCE_PHYSICS_MATERIAL = "instance_physics_material"; +DLLSPEC daeString COLLADA_TYPE_INSTANCE_PHYSICS_MODEL = "instance_physics_model"; +DLLSPEC daeString COLLADA_TYPE_INSTANCE_RIGID_BODY = "instance_rigid_body"; +DLLSPEC daeString COLLADA_TYPE_ANGULAR_VELOCITY = "angular_velocity"; +DLLSPEC daeString COLLADA_TYPE_VELOCITY = "velocity"; +DLLSPEC daeString COLLADA_TYPE_DYNAMIC = "dynamic"; +DLLSPEC daeString COLLADA_TYPE_MASS_FRAME = "mass_frame"; +DLLSPEC daeString COLLADA_TYPE_SHAPE = "shape"; +DLLSPEC daeString COLLADA_TYPE_HOLLOW = "hollow"; +DLLSPEC daeString COLLADA_TYPE_INSTANCE_RIGID_CONSTRAINT = "instance_rigid_constraint"; +DLLSPEC daeString COLLADA_TYPE_LIBRARY_ANIMATIONS = "library_animations"; +DLLSPEC daeString COLLADA_TYPE_LIBRARY_ANIMATION_CLIPS = "library_animation_clips"; +DLLSPEC daeString COLLADA_TYPE_LIBRARY_CAMERAS = "library_cameras"; +DLLSPEC daeString COLLADA_TYPE_LIBRARY_CONTROLLERS = "library_controllers"; +DLLSPEC daeString COLLADA_TYPE_LIBRARY_GEOMETRIES = "library_geometries"; +DLLSPEC daeString COLLADA_TYPE_LIBRARY_EFFECTS = "library_effects"; +DLLSPEC daeString COLLADA_TYPE_LIBRARY_FORCE_FIELDS = "library_force_fields"; +DLLSPEC daeString COLLADA_TYPE_LIBRARY_IMAGES = "library_images"; +DLLSPEC daeString COLLADA_TYPE_LIBRARY_LIGHTS = "library_lights"; +DLLSPEC daeString COLLADA_TYPE_LIBRARY_MATERIALS = "library_materials"; +DLLSPEC daeString COLLADA_TYPE_LIBRARY_NODES = "library_nodes"; +DLLSPEC daeString COLLADA_TYPE_LIBRARY_PHYSICS_MATERIALS = "library_physics_materials"; +DLLSPEC daeString COLLADA_TYPE_LIBRARY_PHYSICS_MODELS = "library_physics_models"; +DLLSPEC daeString COLLADA_TYPE_LIBRARY_PHYSICS_SCENES = "library_physics_scenes"; +DLLSPEC daeString COLLADA_TYPE_LIBRARY_VISUAL_SCENES = "library_visual_scenes"; +DLLSPEC daeString COLLADA_TYPE_FX_PROFILE_ABSTRACT = "fx_profile_abstract"; +DLLSPEC daeString COLLADA_TYPE_EFFECT = "effect"; +DLLSPEC daeString COLLADA_TYPE_GL_HOOK_ABSTRACT = "gl_hook_abstract"; +DLLSPEC daeString COLLADA_TYPE_PROFILE_GLSL = "profile_GLSL"; +DLLSPEC daeString COLLADA_TYPE_PASS = "pass"; +DLLSPEC daeString COLLADA_TYPE_DRAW = "draw"; +DLLSPEC daeString COLLADA_TYPE_SHADER = "shader"; +DLLSPEC daeString COLLADA_TYPE_COMPILER_TARGET = "compiler_target"; +DLLSPEC daeString COLLADA_TYPE_COMPILER_OPTIONS = "compiler_options"; +DLLSPEC daeString COLLADA_TYPE_PROFILE_COMMON = "profile_COMMON"; +DLLSPEC daeString COLLADA_TYPE_CONSTANT = "constant"; +DLLSPEC daeString COLLADA_TYPE_LAMBERT = "lambert"; +DLLSPEC daeString COLLADA_TYPE_PHONG = "phong"; +DLLSPEC daeString COLLADA_TYPE_BLINN = "blinn"; +DLLSPEC daeString COLLADA_TYPE_PROFILE_CG = "profile_CG"; +DLLSPEC daeString COLLADA_TYPE_PROFILE_GLES = "profile_GLES"; +DLLSPEC daeString COLLADA_TYPE_COLOR_TARGET = "color_target"; +DLLSPEC daeString COLLADA_TYPE_DEPTH_TARGET = "depth_target"; +DLLSPEC daeString COLLADA_TYPE_STENCIL_TARGET = "stencil_target"; +DLLSPEC daeString COLLADA_TYPE_COLOR_CLEAR = "color_clear"; +DLLSPEC daeString COLLADA_TYPE_DEPTH_CLEAR = "depth_clear"; +DLLSPEC daeString COLLADA_TYPE_STENCIL_CLEAR = "stencil_clear"; +DLLSPEC daeString COLLADA_TYPE_BOX = "box"; +DLLSPEC daeString COLLADA_TYPE_HALF_EXTENTS = "half_extents"; +DLLSPEC daeString COLLADA_TYPE_PLANE = "plane"; +DLLSPEC daeString COLLADA_TYPE_EQUATION = "equation"; +DLLSPEC daeString COLLADA_TYPE_SPHERE = "sphere"; +DLLSPEC daeString COLLADA_TYPE_RADIUS = "radius"; +DLLSPEC daeString COLLADA_TYPE_ELLIPSOID = "ellipsoid"; +DLLSPEC daeString COLLADA_TYPE_CYLINDER = "cylinder"; +DLLSPEC daeString COLLADA_TYPE_HEIGHT = "height"; +DLLSPEC daeString COLLADA_TYPE_TAPERED_CYLINDER = "tapered_cylinder"; +DLLSPEC daeString COLLADA_TYPE_RADIUS1 = "radius1"; +DLLSPEC daeString COLLADA_TYPE_RADIUS2 = "radius2"; +DLLSPEC daeString COLLADA_TYPE_CAPSULE = "capsule"; +DLLSPEC daeString COLLADA_TYPE_TAPERED_CAPSULE = "tapered_capsule"; +DLLSPEC daeString COLLADA_TYPE_CONVEX_MESH = "convex_mesh"; +DLLSPEC daeString COLLADA_TYPE_FORCE_FIELD = "force_field"; +DLLSPEC daeString COLLADA_TYPE_PHYSICS_MATERIAL = "physics_material"; +DLLSPEC daeString COLLADA_TYPE_PHYSICS_SCENE = "physics_scene"; +DLLSPEC daeString COLLADA_TYPE_RIGID_BODY = "rigid_body"; +DLLSPEC daeString COLLADA_TYPE_RIGID_CONSTRAINT = "rigid_constraint"; +DLLSPEC daeString COLLADA_TYPE_REF_ATTACHMENT = "ref_attachment"; +DLLSPEC daeString COLLADA_TYPE_ATTACHMENT = "attachment"; +DLLSPEC daeString COLLADA_TYPE_ENABLED = "enabled"; +DLLSPEC daeString COLLADA_TYPE_INTERPENETRATE = "interpenetrate"; +DLLSPEC daeString COLLADA_TYPE_LIMITS = "limits"; +DLLSPEC daeString COLLADA_TYPE_SWING_CONE_AND_TWIST = "swing_cone_and_twist"; +DLLSPEC daeString COLLADA_TYPE_LINEAR = "linear"; +DLLSPEC daeString COLLADA_TYPE_SPRING = "spring"; +DLLSPEC daeString COLLADA_TYPE_ANGULAR = "angular"; +DLLSPEC daeString COLLADA_TYPE_PHYSICS_MODEL = "physics_model"; + +DLLSPEC daeString COLLADA_ELEMENT_COLLADA = "COLLADA"; +DLLSPEC daeString COLLADA_ELEMENT_EXTRA = "extra"; +DLLSPEC daeString COLLADA_ELEMENT_CHANNELS = "channels"; +DLLSPEC daeString COLLADA_ELEMENT_RANGE = "range"; +DLLSPEC daeString COLLADA_ELEMENT_PRECISION = "precision"; +DLLSPEC daeString COLLADA_ELEMENT_OPTION = "option"; +DLLSPEC daeString COLLADA_ELEMENT_ALL = "all"; +DLLSPEC daeString COLLADA_ELEMENT_PRIMARY = "primary"; +DLLSPEC daeString COLLADA_ELEMENT_FACE = "face"; +DLLSPEC daeString COLLADA_ELEMENT_ORDER = "order"; +DLLSPEC daeString COLLADA_ELEMENT_FX_SURFACE_INIT_COMMON = "fx_surface_init_common"; +DLLSPEC daeString COLLADA_ELEMENT_FORMAT = "format"; +DLLSPEC daeString COLLADA_ELEMENT_FORMAT_HINT = "format_hint"; +DLLSPEC daeString COLLADA_ELEMENT_SIZE = "size"; +DLLSPEC daeString COLLADA_ELEMENT_VIEWPORT_RATIO = "viewport_ratio"; +DLLSPEC daeString COLLADA_ELEMENT_MIP_LEVELS = "mip_levels"; +DLLSPEC daeString COLLADA_ELEMENT_MIPMAP_GENERATE = "mipmap_generate"; +DLLSPEC daeString COLLADA_ELEMENT_SOURCE = "source"; +DLLSPEC daeString COLLADA_ELEMENT_WRAP_S = "wrap_s"; +DLLSPEC daeString COLLADA_ELEMENT_MINFILTER = "minfilter"; +DLLSPEC daeString COLLADA_ELEMENT_MAGFILTER = "magfilter"; +DLLSPEC daeString COLLADA_ELEMENT_MIPFILTER = "mipfilter"; +DLLSPEC daeString COLLADA_ELEMENT_BORDER_COLOR = "border_color"; +DLLSPEC daeString COLLADA_ELEMENT_MIPMAP_MAXLEVEL = "mipmap_maxlevel"; +DLLSPEC daeString COLLADA_ELEMENT_MIPMAP_BIAS = "mipmap_bias"; +DLLSPEC daeString COLLADA_ELEMENT_WRAP_T = "wrap_t"; +DLLSPEC daeString COLLADA_ELEMENT_WRAP_P = "wrap_p"; +DLLSPEC daeString COLLADA_ELEMENT_FX_ANNOTATE_TYPE_COMMON = "fx_annotate_type_common"; +DLLSPEC daeString COLLADA_ELEMENT_ANNOTATE = "annotate"; +DLLSPEC daeString COLLADA_ELEMENT_SEMANTIC = "semantic"; +DLLSPEC daeString COLLADA_ELEMENT_MODIFIER = "modifier"; +DLLSPEC daeString COLLADA_ELEMENT_FX_BASIC_TYPE_COMMON = "fx_basic_type_common"; +DLLSPEC daeString COLLADA_ELEMENT_GLSL_PARAM_TYPE = "glsl_param_type"; +DLLSPEC daeString COLLADA_ELEMENT_ARRAY = "array"; +DLLSPEC daeString COLLADA_ELEMENT_GENERATOR = "generator"; +DLLSPEC daeString COLLADA_ELEMENT_CODE = "code"; +DLLSPEC daeString COLLADA_ELEMENT_INCLUDE = "include"; +DLLSPEC daeString COLLADA_ELEMENT_NAME = "name"; +DLLSPEC daeString COLLADA_ELEMENT_SETPARAM = "setparam"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT = "float"; +DLLSPEC daeString COLLADA_ELEMENT_PARAM = "param"; +DLLSPEC daeString COLLADA_ELEMENT_COLOR = "color"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURE = "texture"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT2 = "float2"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT3 = "float3"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT4 = "float4"; +DLLSPEC daeString COLLADA_ELEMENT_SURFACE = "surface"; +DLLSPEC daeString COLLADA_ELEMENT_SAMPLER2D = "sampler2D"; +DLLSPEC daeString COLLADA_ELEMENT_CG_PARAM_TYPE = "cg_param_type"; +DLLSPEC daeString COLLADA_ELEMENT_USERTYPE = "usertype"; +DLLSPEC daeString COLLADA_ELEMENT_CONNECT_PARAM = "connect_param"; +DLLSPEC daeString COLLADA_ELEMENT_CONSTANT = "constant"; +DLLSPEC daeString COLLADA_ELEMENT_ARGUMENT = "argument"; +DLLSPEC daeString COLLADA_ELEMENT_RGB = "RGB"; +DLLSPEC daeString COLLADA_ELEMENT_ALPHA = "alpha"; +DLLSPEC daeString COLLADA_ELEMENT_TEXCOMBINER = "texcombiner"; +DLLSPEC daeString COLLADA_ELEMENT_TEXENV = "texenv"; +DLLSPEC daeString COLLADA_ELEMENT_SAMPLER_STATE = "sampler_state"; +DLLSPEC daeString COLLADA_ELEMENT_TEXCOORD = "texcoord"; +DLLSPEC daeString COLLADA_ELEMENT_GLES_BASIC_TYPE_COMMON = "gles_basic_type_common"; +DLLSPEC daeString COLLADA_ELEMENT_INIT_AS_NULL = "init_as_null"; +DLLSPEC daeString COLLADA_ELEMENT_INIT_AS_TARGET = "init_as_target"; +DLLSPEC daeString COLLADA_ELEMENT_INIT_CUBE = "init_cube"; +DLLSPEC daeString COLLADA_ELEMENT_INIT_VOLUME = "init_volume"; +DLLSPEC daeString COLLADA_ELEMENT_INIT_PLANAR = "init_planar"; +DLLSPEC daeString COLLADA_ELEMENT_INIT_FROM = "init_from"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL = "bool"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL2 = "bool2"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL3 = "bool3"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL4 = "bool4"; +DLLSPEC daeString COLLADA_ELEMENT_INT = "int"; +DLLSPEC daeString COLLADA_ELEMENT_INT2 = "int2"; +DLLSPEC daeString COLLADA_ELEMENT_INT3 = "int3"; +DLLSPEC daeString COLLADA_ELEMENT_INT4 = "int4"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT2X2 = "float2x2"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT3X3 = "float3x3"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT4X4 = "float4x4"; +DLLSPEC daeString COLLADA_ELEMENT_STRING = "string"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT1X1 = "float1x1"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT1X2 = "float1x2"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT1X3 = "float1x3"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT1X4 = "float1x4"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT2X1 = "float2x1"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT2X3 = "float2x3"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT2X4 = "float2x4"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT3X1 = "float3x1"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT3X2 = "float3x2"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT3X4 = "float3x4"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT4X1 = "float4x1"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT4X2 = "float4x2"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT4X3 = "float4x3"; +DLLSPEC daeString COLLADA_ELEMENT_SAMPLER1D = "sampler1D"; +DLLSPEC daeString COLLADA_ELEMENT_SAMPLER3D = "sampler3D"; +DLLSPEC daeString COLLADA_ELEMENT_SAMPLERCUBE = "samplerCUBE"; +DLLSPEC daeString COLLADA_ELEMENT_SAMPLERRECT = "samplerRECT"; +DLLSPEC daeString COLLADA_ELEMENT_SAMPLERDEPTH = "samplerDEPTH"; +DLLSPEC daeString COLLADA_ELEMENT_ENUM = "enum"; +DLLSPEC daeString COLLADA_ELEMENT_ALPHA_FUNC = "alpha_func"; +DLLSPEC daeString COLLADA_ELEMENT_BLEND_FUNC = "blend_func"; +DLLSPEC daeString COLLADA_ELEMENT_BLEND_FUNC_SEPARATE = "blend_func_separate"; +DLLSPEC daeString COLLADA_ELEMENT_BLEND_EQUATION = "blend_equation"; +DLLSPEC daeString COLLADA_ELEMENT_BLEND_EQUATION_SEPARATE = "blend_equation_separate"; +DLLSPEC daeString COLLADA_ELEMENT_COLOR_MATERIAL = "color_material"; +DLLSPEC daeString COLLADA_ELEMENT_CULL_FACE = "cull_face"; +DLLSPEC daeString COLLADA_ELEMENT_DEPTH_FUNC = "depth_func"; +DLLSPEC daeString COLLADA_ELEMENT_FOG_MODE = "fog_mode"; +DLLSPEC daeString COLLADA_ELEMENT_FOG_COORD_SRC = "fog_coord_src"; +DLLSPEC daeString COLLADA_ELEMENT_FRONT_FACE = "front_face"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_MODEL_COLOR_CONTROL = "light_model_color_control"; +DLLSPEC daeString COLLADA_ELEMENT_LOGIC_OP = "logic_op"; +DLLSPEC daeString COLLADA_ELEMENT_POLYGON_MODE = "polygon_mode"; +DLLSPEC daeString COLLADA_ELEMENT_SHADE_MODEL = "shade_model"; +DLLSPEC daeString COLLADA_ELEMENT_STENCIL_FUNC = "stencil_func"; +DLLSPEC daeString COLLADA_ELEMENT_STENCIL_OP = "stencil_op"; +DLLSPEC daeString COLLADA_ELEMENT_STENCIL_FUNC_SEPARATE = "stencil_func_separate"; +DLLSPEC daeString COLLADA_ELEMENT_STENCIL_OP_SEPARATE = "stencil_op_separate"; +DLLSPEC daeString COLLADA_ELEMENT_STENCIL_MASK_SEPARATE = "stencil_mask_separate"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_ENABLE = "light_enable"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_AMBIENT = "light_ambient"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_DIFFUSE = "light_diffuse"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_SPECULAR = "light_specular"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_POSITION = "light_position"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_CONSTANT_ATTENUATION = "light_constant_attenuation"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_LINEAR_ATTENUATION = "light_linear_attenuation"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_QUADRATIC_ATTENUATION = "light_quadratic_attenuation"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_SPOT_CUTOFF = "light_spot_cutoff"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_SPOT_DIRECTION = "light_spot_direction"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_SPOT_EXPONENT = "light_spot_exponent"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURE1D = "texture1D"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURE2D = "texture2D"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURE3D = "texture3D"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURECUBE = "textureCUBE"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURERECT = "textureRECT"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTUREDEPTH = "textureDEPTH"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURE1D_ENABLE = "texture1D_enable"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURE2D_ENABLE = "texture2D_enable"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURE3D_ENABLE = "texture3D_enable"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURECUBE_ENABLE = "textureCUBE_enable"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURERECT_ENABLE = "textureRECT_enable"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTUREDEPTH_ENABLE = "textureDEPTH_enable"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURE_ENV_COLOR = "texture_env_color"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURE_ENV_MODE = "texture_env_mode"; +DLLSPEC daeString COLLADA_ELEMENT_CLIP_PLANE = "clip_plane"; +DLLSPEC daeString COLLADA_ELEMENT_CLIP_PLANE_ENABLE = "clip_plane_enable"; +DLLSPEC daeString COLLADA_ELEMENT_BLEND_COLOR = "blend_color"; +DLLSPEC daeString COLLADA_ELEMENT_CLEAR_COLOR = "clear_color"; +DLLSPEC daeString COLLADA_ELEMENT_CLEAR_STENCIL = "clear_stencil"; +DLLSPEC daeString COLLADA_ELEMENT_CLEAR_DEPTH = "clear_depth"; +DLLSPEC daeString COLLADA_ELEMENT_COLOR_MASK = "color_mask"; +DLLSPEC daeString COLLADA_ELEMENT_DEPTH_BOUNDS = "depth_bounds"; +DLLSPEC daeString COLLADA_ELEMENT_DEPTH_MASK = "depth_mask"; +DLLSPEC daeString COLLADA_ELEMENT_DEPTH_RANGE = "depth_range"; +DLLSPEC daeString COLLADA_ELEMENT_FOG_DENSITY = "fog_density"; +DLLSPEC daeString COLLADA_ELEMENT_FOG_START = "fog_start"; +DLLSPEC daeString COLLADA_ELEMENT_FOG_END = "fog_end"; +DLLSPEC daeString COLLADA_ELEMENT_FOG_COLOR = "fog_color"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_MODEL_AMBIENT = "light_model_ambient"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHTING_ENABLE = "lighting_enable"; +DLLSPEC daeString COLLADA_ELEMENT_LINE_STIPPLE = "line_stipple"; +DLLSPEC daeString COLLADA_ELEMENT_LINE_WIDTH = "line_width"; +DLLSPEC daeString COLLADA_ELEMENT_MATERIAL_AMBIENT = "material_ambient"; +DLLSPEC daeString COLLADA_ELEMENT_MATERIAL_DIFFUSE = "material_diffuse"; +DLLSPEC daeString COLLADA_ELEMENT_MATERIAL_EMISSION = "material_emission"; +DLLSPEC daeString COLLADA_ELEMENT_MATERIAL_SHININESS = "material_shininess"; +DLLSPEC daeString COLLADA_ELEMENT_MATERIAL_SPECULAR = "material_specular"; +DLLSPEC daeString COLLADA_ELEMENT_MODEL_VIEW_MATRIX = "model_view_matrix"; +DLLSPEC daeString COLLADA_ELEMENT_POINT_DISTANCE_ATTENUATION = "point_distance_attenuation"; +DLLSPEC daeString COLLADA_ELEMENT_POINT_FADE_THRESHOLD_SIZE = "point_fade_threshold_size"; +DLLSPEC daeString COLLADA_ELEMENT_POINT_SIZE = "point_size"; +DLLSPEC daeString COLLADA_ELEMENT_POINT_SIZE_MIN = "point_size_min"; +DLLSPEC daeString COLLADA_ELEMENT_POINT_SIZE_MAX = "point_size_max"; +DLLSPEC daeString COLLADA_ELEMENT_POLYGON_OFFSET = "polygon_offset"; +DLLSPEC daeString COLLADA_ELEMENT_PROJECTION_MATRIX = "projection_matrix"; +DLLSPEC daeString COLLADA_ELEMENT_SCISSOR = "scissor"; +DLLSPEC daeString COLLADA_ELEMENT_STENCIL_MASK = "stencil_mask"; +DLLSPEC daeString COLLADA_ELEMENT_ALPHA_TEST_ENABLE = "alpha_test_enable"; +DLLSPEC daeString COLLADA_ELEMENT_AUTO_NORMAL_ENABLE = "auto_normal_enable"; +DLLSPEC daeString COLLADA_ELEMENT_BLEND_ENABLE = "blend_enable"; +DLLSPEC daeString COLLADA_ELEMENT_COLOR_LOGIC_OP_ENABLE = "color_logic_op_enable"; +DLLSPEC daeString COLLADA_ELEMENT_COLOR_MATERIAL_ENABLE = "color_material_enable"; +DLLSPEC daeString COLLADA_ELEMENT_CULL_FACE_ENABLE = "cull_face_enable"; +DLLSPEC daeString COLLADA_ELEMENT_DEPTH_BOUNDS_ENABLE = "depth_bounds_enable"; +DLLSPEC daeString COLLADA_ELEMENT_DEPTH_CLAMP_ENABLE = "depth_clamp_enable"; +DLLSPEC daeString COLLADA_ELEMENT_DEPTH_TEST_ENABLE = "depth_test_enable"; +DLLSPEC daeString COLLADA_ELEMENT_DITHER_ENABLE = "dither_enable"; +DLLSPEC daeString COLLADA_ELEMENT_FOG_ENABLE = "fog_enable"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_MODEL_LOCAL_VIEWER_ENABLE = "light_model_local_viewer_enable"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_MODEL_TWO_SIDE_ENABLE = "light_model_two_side_enable"; +DLLSPEC daeString COLLADA_ELEMENT_LINE_SMOOTH_ENABLE = "line_smooth_enable"; +DLLSPEC daeString COLLADA_ELEMENT_LINE_STIPPLE_ENABLE = "line_stipple_enable"; +DLLSPEC daeString COLLADA_ELEMENT_LOGIC_OP_ENABLE = "logic_op_enable"; +DLLSPEC daeString COLLADA_ELEMENT_MULTISAMPLE_ENABLE = "multisample_enable"; +DLLSPEC daeString COLLADA_ELEMENT_NORMALIZE_ENABLE = "normalize_enable"; +DLLSPEC daeString COLLADA_ELEMENT_POINT_SMOOTH_ENABLE = "point_smooth_enable"; +DLLSPEC daeString COLLADA_ELEMENT_POLYGON_OFFSET_FILL_ENABLE = "polygon_offset_fill_enable"; +DLLSPEC daeString COLLADA_ELEMENT_POLYGON_OFFSET_LINE_ENABLE = "polygon_offset_line_enable"; +DLLSPEC daeString COLLADA_ELEMENT_POLYGON_OFFSET_POINT_ENABLE = "polygon_offset_point_enable"; +DLLSPEC daeString COLLADA_ELEMENT_POLYGON_SMOOTH_ENABLE = "polygon_smooth_enable"; +DLLSPEC daeString COLLADA_ELEMENT_POLYGON_STIPPLE_ENABLE = "polygon_stipple_enable"; +DLLSPEC daeString COLLADA_ELEMENT_RESCALE_NORMAL_ENABLE = "rescale_normal_enable"; +DLLSPEC daeString COLLADA_ELEMENT_SAMPLE_ALPHA_TO_COVERAGE_ENABLE = "sample_alpha_to_coverage_enable"; +DLLSPEC daeString COLLADA_ELEMENT_SAMPLE_ALPHA_TO_ONE_ENABLE = "sample_alpha_to_one_enable"; +DLLSPEC daeString COLLADA_ELEMENT_SAMPLE_COVERAGE_ENABLE = "sample_coverage_enable"; +DLLSPEC daeString COLLADA_ELEMENT_SCISSOR_TEST_ENABLE = "scissor_test_enable"; +DLLSPEC daeString COLLADA_ELEMENT_STENCIL_TEST_ENABLE = "stencil_test_enable"; +DLLSPEC daeString COLLADA_ELEMENT_GL_HOOK_ABSTRACT = "gl_hook_abstract"; +DLLSPEC daeString COLLADA_ELEMENT_FUNC = "func"; +DLLSPEC daeString COLLADA_ELEMENT_VALUE = "value"; +DLLSPEC daeString COLLADA_ELEMENT_SRC = "src"; +DLLSPEC daeString COLLADA_ELEMENT_DEST = "dest"; +DLLSPEC daeString COLLADA_ELEMENT_SRC_RGB = "src_rgb"; +DLLSPEC daeString COLLADA_ELEMENT_DEST_RGB = "dest_rgb"; +DLLSPEC daeString COLLADA_ELEMENT_SRC_ALPHA = "src_alpha"; +DLLSPEC daeString COLLADA_ELEMENT_DEST_ALPHA = "dest_alpha"; +DLLSPEC daeString COLLADA_ELEMENT_rgb = "rgb"; +DLLSPEC daeString COLLADA_ELEMENT_MODE = "mode"; +DLLSPEC daeString COLLADA_ELEMENT_REF = "ref"; +DLLSPEC daeString COLLADA_ELEMENT_MASK = "mask"; +DLLSPEC daeString COLLADA_ELEMENT_FAIL = "fail"; +DLLSPEC daeString COLLADA_ELEMENT_ZFAIL = "zfail"; +DLLSPEC daeString COLLADA_ELEMENT_ZPASS = "zpass"; +DLLSPEC daeString COLLADA_ELEMENT_FRONT = "front"; +DLLSPEC daeString COLLADA_ELEMENT_BACK = "back"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL1 = "bool1"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL1X1 = "bool1x1"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL1X2 = "bool1x2"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL1X3 = "bool1x3"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL1X4 = "bool1x4"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL2X1 = "bool2x1"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL2X2 = "bool2x2"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL2X3 = "bool2x3"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL2X4 = "bool2x4"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL3X1 = "bool3x1"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL3X2 = "bool3x2"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL3X3 = "bool3x3"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL3X4 = "bool3x4"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL4X1 = "bool4x1"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL4X2 = "bool4x2"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL4X3 = "bool4x3"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL4X4 = "bool4x4"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT1 = "float1"; +DLLSPEC daeString COLLADA_ELEMENT_INT1 = "int1"; +DLLSPEC daeString COLLADA_ELEMENT_INT1X1 = "int1x1"; +DLLSPEC daeString COLLADA_ELEMENT_INT1X2 = "int1x2"; +DLLSPEC daeString COLLADA_ELEMENT_INT1X3 = "int1x3"; +DLLSPEC daeString COLLADA_ELEMENT_INT1X4 = "int1x4"; +DLLSPEC daeString COLLADA_ELEMENT_INT2X1 = "int2x1"; +DLLSPEC daeString COLLADA_ELEMENT_INT2X2 = "int2x2"; +DLLSPEC daeString COLLADA_ELEMENT_INT2X3 = "int2x3"; +DLLSPEC daeString COLLADA_ELEMENT_INT2X4 = "int2x4"; +DLLSPEC daeString COLLADA_ELEMENT_INT3X1 = "int3x1"; +DLLSPEC daeString COLLADA_ELEMENT_INT3X2 = "int3x2"; +DLLSPEC daeString COLLADA_ELEMENT_INT3X3 = "int3x3"; +DLLSPEC daeString COLLADA_ELEMENT_INT3X4 = "int3x4"; +DLLSPEC daeString COLLADA_ELEMENT_INT4X1 = "int4x1"; +DLLSPEC daeString COLLADA_ELEMENT_INT4X2 = "int4x2"; +DLLSPEC daeString COLLADA_ELEMENT_INT4X3 = "int4x3"; +DLLSPEC daeString COLLADA_ELEMENT_INT4X4 = "int4x4"; +DLLSPEC daeString COLLADA_ELEMENT_HALF = "half"; +DLLSPEC daeString COLLADA_ELEMENT_HALF1 = "half1"; +DLLSPEC daeString COLLADA_ELEMENT_HALF2 = "half2"; +DLLSPEC daeString COLLADA_ELEMENT_HALF3 = "half3"; +DLLSPEC daeString COLLADA_ELEMENT_HALF4 = "half4"; +DLLSPEC daeString COLLADA_ELEMENT_HALF1X1 = "half1x1"; +DLLSPEC daeString COLLADA_ELEMENT_HALF1X2 = "half1x2"; +DLLSPEC daeString COLLADA_ELEMENT_HALF1X3 = "half1x3"; +DLLSPEC daeString COLLADA_ELEMENT_HALF1X4 = "half1x4"; +DLLSPEC daeString COLLADA_ELEMENT_HALF2X1 = "half2x1"; +DLLSPEC daeString COLLADA_ELEMENT_HALF2X2 = "half2x2"; +DLLSPEC daeString COLLADA_ELEMENT_HALF2X3 = "half2x3"; +DLLSPEC daeString COLLADA_ELEMENT_HALF2X4 = "half2x4"; +DLLSPEC daeString COLLADA_ELEMENT_HALF3X1 = "half3x1"; +DLLSPEC daeString COLLADA_ELEMENT_HALF3X2 = "half3x2"; +DLLSPEC daeString COLLADA_ELEMENT_HALF3X3 = "half3x3"; +DLLSPEC daeString COLLADA_ELEMENT_HALF3X4 = "half3x4"; +DLLSPEC daeString COLLADA_ELEMENT_HALF4X1 = "half4x1"; +DLLSPEC daeString COLLADA_ELEMENT_HALF4X2 = "half4x2"; +DLLSPEC daeString COLLADA_ELEMENT_HALF4X3 = "half4x3"; +DLLSPEC daeString COLLADA_ELEMENT_HALF4X4 = "half4x4"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED = "fixed"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED1 = "fixed1"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED2 = "fixed2"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED3 = "fixed3"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED4 = "fixed4"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED1X1 = "fixed1x1"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED1X2 = "fixed1x2"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED1X3 = "fixed1x3"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED1X4 = "fixed1x4"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED2X1 = "fixed2x1"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED2X2 = "fixed2x2"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED2X3 = "fixed2x3"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED2X4 = "fixed2x4"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED3X1 = "fixed3x1"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED3X2 = "fixed3x2"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED3X3 = "fixed3x3"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED3X4 = "fixed3x4"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED4X1 = "fixed4x1"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED4X2 = "fixed4x2"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED4X3 = "fixed4x3"; +DLLSPEC daeString COLLADA_ELEMENT_FIXED4X4 = "fixed4x4"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURE_PIPELINE = "texture_pipeline"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT_LINEAR_ATTENUTATION = "light_linear_attenutation"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURE_PIPELINE_ENABLE = "texture_pipeline_enable"; +DLLSPEC daeString COLLADA_ELEMENT_TEXTURE_UNIT = "texture_unit"; +DLLSPEC daeString COLLADA_ELEMENT_ASSET = "asset"; +DLLSPEC daeString COLLADA_ELEMENT_LIBRARY_ANIMATIONS = "library_animations"; +DLLSPEC daeString COLLADA_ELEMENT_LIBRARY_ANIMATION_CLIPS = "library_animation_clips"; +DLLSPEC daeString COLLADA_ELEMENT_LIBRARY_CAMERAS = "library_cameras"; +DLLSPEC daeString COLLADA_ELEMENT_LIBRARY_CONTROLLERS = "library_controllers"; +DLLSPEC daeString COLLADA_ELEMENT_LIBRARY_GEOMETRIES = "library_geometries"; +DLLSPEC daeString COLLADA_ELEMENT_LIBRARY_EFFECTS = "library_effects"; +DLLSPEC daeString COLLADA_ELEMENT_LIBRARY_FORCE_FIELDS = "library_force_fields"; +DLLSPEC daeString COLLADA_ELEMENT_LIBRARY_IMAGES = "library_images"; +DLLSPEC daeString COLLADA_ELEMENT_LIBRARY_LIGHTS = "library_lights"; +DLLSPEC daeString COLLADA_ELEMENT_LIBRARY_MATERIALS = "library_materials"; +DLLSPEC daeString COLLADA_ELEMENT_LIBRARY_NODES = "library_nodes"; +DLLSPEC daeString COLLADA_ELEMENT_LIBRARY_PHYSICS_MATERIALS = "library_physics_materials"; +DLLSPEC daeString COLLADA_ELEMENT_LIBRARY_PHYSICS_MODELS = "library_physics_models"; +DLLSPEC daeString COLLADA_ELEMENT_LIBRARY_PHYSICS_SCENES = "library_physics_scenes"; +DLLSPEC daeString COLLADA_ELEMENT_LIBRARY_VISUAL_SCENES = "library_visual_scenes"; +DLLSPEC daeString COLLADA_ELEMENT_SCENE = "scene"; +DLLSPEC daeString COLLADA_ELEMENT_INSTANCE_PHYSICS_SCENE = "instance_physics_scene"; +DLLSPEC daeString COLLADA_ELEMENT_INSTANCE_VISUAL_SCENE = "instance_visual_scene"; +DLLSPEC daeString COLLADA_ELEMENT_IDREF_ARRAY = "IDREF_array"; +DLLSPEC daeString COLLADA_ELEMENT_NAME_ARRAY = "Name_array"; +DLLSPEC daeString COLLADA_ELEMENT_BOOL_ARRAY = "bool_array"; +DLLSPEC daeString COLLADA_ELEMENT_FLOAT_ARRAY = "float_array"; +DLLSPEC daeString COLLADA_ELEMENT_INT_ARRAY = "int_array"; +DLLSPEC daeString COLLADA_ELEMENT_TECHNIQUE_COMMON = "technique_common"; +DLLSPEC daeString COLLADA_ELEMENT_TECHNIQUE = "technique"; +DLLSPEC daeString COLLADA_ELEMENT_ACCESSOR = "accessor"; +DLLSPEC daeString COLLADA_ELEMENT_CONVEX_MESH = "convex_mesh"; +DLLSPEC daeString COLLADA_ELEMENT_MESH = "mesh"; +DLLSPEC daeString COLLADA_ELEMENT_SPLINE = "spline"; +DLLSPEC daeString COLLADA_ELEMENT_VERTICES = "vertices"; +DLLSPEC daeString COLLADA_ELEMENT_LINES = "lines"; +DLLSPEC daeString COLLADA_ELEMENT_LINESTRIPS = "linestrips"; +DLLSPEC daeString COLLADA_ELEMENT_POLYGONS = "polygons"; +DLLSPEC daeString COLLADA_ELEMENT_POLYLIST = "polylist"; +DLLSPEC daeString COLLADA_ELEMENT_TRIANGLES = "triangles"; +DLLSPEC daeString COLLADA_ELEMENT_TRIFANS = "trifans"; +DLLSPEC daeString COLLADA_ELEMENT_TRISTRIPS = "tristrips"; +DLLSPEC daeString COLLADA_ELEMENT_CONTROL_VERTICES = "control_vertices"; +DLLSPEC daeString COLLADA_ELEMENT_INPUT = "input"; +DLLSPEC daeString COLLADA_ELEMENT_P = "p"; +DLLSPEC daeString COLLADA_ELEMENT_PH = "ph"; +DLLSPEC daeString COLLADA_ELEMENT_H = "h"; +DLLSPEC daeString COLLADA_ELEMENT_VCOUNT = "vcount"; +DLLSPEC daeString COLLADA_ELEMENT_DATA = "data"; +DLLSPEC daeString COLLADA_ELEMENT_AMBIENT = "ambient"; +DLLSPEC daeString COLLADA_ELEMENT_DIRECTIONAL = "directional"; +DLLSPEC daeString COLLADA_ELEMENT_POINT = "point"; +DLLSPEC daeString COLLADA_ELEMENT_SPOT = "spot"; +DLLSPEC daeString COLLADA_ELEMENT_CONSTANT_ATTENUATION = "constant_attenuation"; +DLLSPEC daeString COLLADA_ELEMENT_LINEAR_ATTENUATION = "linear_attenuation"; +DLLSPEC daeString COLLADA_ELEMENT_QUADRATIC_ATTENUATION = "quadratic_attenuation"; +DLLSPEC daeString COLLADA_ELEMENT_FALLOFF_ANGLE = "falloff_angle"; +DLLSPEC daeString COLLADA_ELEMENT_FALLOFF_EXPONENT = "falloff_exponent"; +DLLSPEC daeString COLLADA_ELEMENT_INSTANCE_EFFECT = "instance_effect"; +DLLSPEC daeString COLLADA_ELEMENT_OPTICS = "optics"; +DLLSPEC daeString COLLADA_ELEMENT_IMAGER = "imager"; +DLLSPEC daeString COLLADA_ELEMENT_ORTHOGRAPHIC = "orthographic"; +DLLSPEC daeString COLLADA_ELEMENT_PERSPECTIVE = "perspective"; +DLLSPEC daeString COLLADA_ELEMENT_XMAG = "xmag"; +DLLSPEC daeString COLLADA_ELEMENT_YMAG = "ymag"; +DLLSPEC daeString COLLADA_ELEMENT_ASPECT_RATIO = "aspect_ratio"; +DLLSPEC daeString COLLADA_ELEMENT_ZNEAR = "znear"; +DLLSPEC daeString COLLADA_ELEMENT_ZFAR = "zfar"; +DLLSPEC daeString COLLADA_ELEMENT_XFOV = "xfov"; +DLLSPEC daeString COLLADA_ELEMENT_YFOV = "yfov"; +DLLSPEC daeString COLLADA_ELEMENT_SAMPLER = "sampler"; +DLLSPEC daeString COLLADA_ELEMENT_CHANNEL = "channel"; +DLLSPEC daeString COLLADA_ELEMENT_ANIMATION = "animation"; +DLLSPEC daeString COLLADA_ELEMENT_INSTANCE_ANIMATION = "instance_animation"; +DLLSPEC daeString COLLADA_ELEMENT_SKIN = "skin"; +DLLSPEC daeString COLLADA_ELEMENT_MORPH = "morph"; +DLLSPEC daeString COLLADA_ELEMENT_BIND_SHAPE_MATRIX = "bind_shape_matrix"; +DLLSPEC daeString COLLADA_ELEMENT_JOINTS = "joints"; +DLLSPEC daeString COLLADA_ELEMENT_VERTEX_WEIGHTS = "vertex_weights"; +DLLSPEC daeString COLLADA_ELEMENT_V = "v"; +DLLSPEC daeString COLLADA_ELEMENT_TARGETS = "targets"; +DLLSPEC daeString COLLADA_ELEMENT_CONTRIBUTOR = "contributor"; +DLLSPEC daeString COLLADA_ELEMENT_CREATED = "created"; +DLLSPEC daeString COLLADA_ELEMENT_KEYWORDS = "keywords"; +DLLSPEC daeString COLLADA_ELEMENT_MODIFIED = "modified"; +DLLSPEC daeString COLLADA_ELEMENT_REVISION = "revision"; +DLLSPEC daeString COLLADA_ELEMENT_SUBJECT = "subject"; +DLLSPEC daeString COLLADA_ELEMENT_TITLE = "title"; +DLLSPEC daeString COLLADA_ELEMENT_UNIT = "unit"; +DLLSPEC daeString COLLADA_ELEMENT_UP_AXIS = "up_axis"; +DLLSPEC daeString COLLADA_ELEMENT_AUTHOR = "author"; +DLLSPEC daeString COLLADA_ELEMENT_AUTHORING_TOOL = "authoring_tool"; +DLLSPEC daeString COLLADA_ELEMENT_COMMENTS = "comments"; +DLLSPEC daeString COLLADA_ELEMENT_COPYRIGHT = "copyright"; +DLLSPEC daeString COLLADA_ELEMENT_SOURCE_DATA = "source_data"; +DLLSPEC daeString COLLADA_ELEMENT_LOOKAT = "lookat"; +DLLSPEC daeString COLLADA_ELEMENT_MATRIX = "matrix"; +DLLSPEC daeString COLLADA_ELEMENT_ROTATE = "rotate"; +DLLSPEC daeString COLLADA_ELEMENT_SCALE = "scale"; +DLLSPEC daeString COLLADA_ELEMENT_SKEW = "skew"; +DLLSPEC daeString COLLADA_ELEMENT_TRANSLATE = "translate"; +DLLSPEC daeString COLLADA_ELEMENT_INSTANCE_CAMERA = "instance_camera"; +DLLSPEC daeString COLLADA_ELEMENT_INSTANCE_CONTROLLER = "instance_controller"; +DLLSPEC daeString COLLADA_ELEMENT_INSTANCE_GEOMETRY = "instance_geometry"; +DLLSPEC daeString COLLADA_ELEMENT_INSTANCE_LIGHT = "instance_light"; +DLLSPEC daeString COLLADA_ELEMENT_INSTANCE_NODE = "instance_node"; +DLLSPEC daeString COLLADA_ELEMENT_NODE = "node"; +DLLSPEC daeString COLLADA_ELEMENT_EVALUATE_SCENE = "evaluate_scene"; +DLLSPEC daeString COLLADA_ELEMENT_RENDER = "render"; +DLLSPEC daeString COLLADA_ELEMENT_LAYER = "layer"; +DLLSPEC daeString COLLADA_ELEMENT_INSTANCE_MATERIAL = "instance_material"; +DLLSPEC daeString COLLADA_ELEMENT_SKELETON = "skeleton"; +DLLSPEC daeString COLLADA_ELEMENT_BIND_MATERIAL = "bind_material"; +DLLSPEC daeString COLLADA_ELEMENT_TECHNIQUE_HINT = "technique_hint"; +DLLSPEC daeString COLLADA_ELEMENT_BIND = "bind"; +DLLSPEC daeString COLLADA_ELEMENT_BIND_VERTEX_INPUT = "bind_vertex_input"; +DLLSPEC daeString COLLADA_ELEMENT_INSTANCE_FORCE_FIELD = "instance_force_field"; +DLLSPEC daeString COLLADA_ELEMENT_INSTANCE_RIGID_BODY = "instance_rigid_body"; +DLLSPEC daeString COLLADA_ELEMENT_INSTANCE_RIGID_CONSTRAINT = "instance_rigid_constraint"; +DLLSPEC daeString COLLADA_ELEMENT_ANGULAR_VELOCITY = "angular_velocity"; +DLLSPEC daeString COLLADA_ELEMENT_VELOCITY = "velocity"; +DLLSPEC daeString COLLADA_ELEMENT_DYNAMIC = "dynamic"; +DLLSPEC daeString COLLADA_ELEMENT_MASS = "mass"; +DLLSPEC daeString COLLADA_ELEMENT_MASS_FRAME = "mass_frame"; +DLLSPEC daeString COLLADA_ELEMENT_INERTIA = "inertia"; +DLLSPEC daeString COLLADA_ELEMENT_INSTANCE_PHYSICS_MATERIAL = "instance_physics_material"; +DLLSPEC daeString COLLADA_ELEMENT_PHYSICS_MATERIAL = "physics_material"; +DLLSPEC daeString COLLADA_ELEMENT_SHAPE = "shape"; +DLLSPEC daeString COLLADA_ELEMENT_HOLLOW = "hollow"; +DLLSPEC daeString COLLADA_ELEMENT_DENSITY = "density"; +DLLSPEC daeString COLLADA_ELEMENT_PLANE = "plane"; +DLLSPEC daeString COLLADA_ELEMENT_BOX = "box"; +DLLSPEC daeString COLLADA_ELEMENT_SPHERE = "sphere"; +DLLSPEC daeString COLLADA_ELEMENT_CYLINDER = "cylinder"; +DLLSPEC daeString COLLADA_ELEMENT_TAPERED_CYLINDER = "tapered_cylinder"; +DLLSPEC daeString COLLADA_ELEMENT_CAPSULE = "capsule"; +DLLSPEC daeString COLLADA_ELEMENT_TAPERED_CAPSULE = "tapered_capsule"; +DLLSPEC daeString COLLADA_ELEMENT_ANIMATION_CLIP = "animation_clip"; +DLLSPEC daeString COLLADA_ELEMENT_CAMERA = "camera"; +DLLSPEC daeString COLLADA_ELEMENT_CONTROLLER = "controller"; +DLLSPEC daeString COLLADA_ELEMENT_GEOMETRY = "geometry"; +DLLSPEC daeString COLLADA_ELEMENT_EFFECT = "effect"; +DLLSPEC daeString COLLADA_ELEMENT_FORCE_FIELD = "force_field"; +DLLSPEC daeString COLLADA_ELEMENT_IMAGE = "image"; +DLLSPEC daeString COLLADA_ELEMENT_LIGHT = "light"; +DLLSPEC daeString COLLADA_ELEMENT_MATERIAL = "material"; +DLLSPEC daeString COLLADA_ELEMENT_PHYSICS_MODEL = "physics_model"; +DLLSPEC daeString COLLADA_ELEMENT_PHYSICS_SCENE = "physics_scene"; +DLLSPEC daeString COLLADA_ELEMENT_VISUAL_SCENE = "visual_scene"; +DLLSPEC daeString COLLADA_ELEMENT_NEWPARAM = "newparam"; +DLLSPEC daeString COLLADA_ELEMENT_FX_PROFILE_ABSTRACT = "fx_profile_abstract"; +DLLSPEC daeString COLLADA_ELEMENT_PROFILE_GLSL = "profile_GLSL"; +DLLSPEC daeString COLLADA_ELEMENT_PASS = "pass"; +DLLSPEC daeString COLLADA_ELEMENT_COLOR_TARGET = "color_target"; +DLLSPEC daeString COLLADA_ELEMENT_DEPTH_TARGET = "depth_target"; +DLLSPEC daeString COLLADA_ELEMENT_STENCIL_TARGET = "stencil_target"; +DLLSPEC daeString COLLADA_ELEMENT_COLOR_CLEAR = "color_clear"; +DLLSPEC daeString COLLADA_ELEMENT_DEPTH_CLEAR = "depth_clear"; +DLLSPEC daeString COLLADA_ELEMENT_STENCIL_CLEAR = "stencil_clear"; +DLLSPEC daeString COLLADA_ELEMENT_DRAW = "draw"; +DLLSPEC daeString COLLADA_ELEMENT_GL_PIPELINE_SETTINGS = "gl_pipeline_settings"; +DLLSPEC daeString COLLADA_ELEMENT_SHADER = "shader"; +DLLSPEC daeString COLLADA_ELEMENT_COMPILER_TARGET = "compiler_target"; +DLLSPEC daeString COLLADA_ELEMENT_COMPILER_OPTIONS = "compiler_options"; +DLLSPEC daeString COLLADA_ELEMENT_PROFILE_COMMON = "profile_COMMON"; +DLLSPEC daeString COLLADA_ELEMENT_LAMBERT = "lambert"; +DLLSPEC daeString COLLADA_ELEMENT_PHONG = "phong"; +DLLSPEC daeString COLLADA_ELEMENT_BLINN = "blinn"; +DLLSPEC daeString COLLADA_ELEMENT_EMISSION = "emission"; +DLLSPEC daeString COLLADA_ELEMENT_REFLECTIVE = "reflective"; +DLLSPEC daeString COLLADA_ELEMENT_REFLECTIVITY = "reflectivity"; +DLLSPEC daeString COLLADA_ELEMENT_TRANSPARENT = "transparent"; +DLLSPEC daeString COLLADA_ELEMENT_TRANSPARENCY = "transparency"; +DLLSPEC daeString COLLADA_ELEMENT_INDEX_OF_REFRACTION = "index_of_refraction"; +DLLSPEC daeString COLLADA_ELEMENT_DIFFUSE = "diffuse"; +DLLSPEC daeString COLLADA_ELEMENT_SPECULAR = "specular"; +DLLSPEC daeString COLLADA_ELEMENT_SHININESS = "shininess"; +DLLSPEC daeString COLLADA_ELEMENT_PROFILE_CG = "profile_CG"; +DLLSPEC daeString COLLADA_ELEMENT_PROFILE_GLES = "profile_GLES"; +DLLSPEC daeString COLLADA_ELEMENT_GLES_PIPELINE_SETTINGS = "gles_pipeline_settings"; +DLLSPEC daeString COLLADA_ELEMENT_HALF_EXTENTS = "half_extents"; +DLLSPEC daeString COLLADA_ELEMENT_EQUATION = "equation"; +DLLSPEC daeString COLLADA_ELEMENT_RADIUS = "radius"; +DLLSPEC daeString COLLADA_ELEMENT_HEIGHT = "height"; +DLLSPEC daeString COLLADA_ELEMENT_RADIUS1 = "radius1"; +DLLSPEC daeString COLLADA_ELEMENT_RADIUS2 = "radius2"; +DLLSPEC daeString COLLADA_ELEMENT_DYNAMIC_FRICTION = "dynamic_friction"; +DLLSPEC daeString COLLADA_ELEMENT_RESTITUTION = "restitution"; +DLLSPEC daeString COLLADA_ELEMENT_STATIC_FRICTION = "static_friction"; +DLLSPEC daeString COLLADA_ELEMENT_INSTANCE_PHYSICS_MODEL = "instance_physics_model"; +DLLSPEC daeString COLLADA_ELEMENT_GRAVITY = "gravity"; +DLLSPEC daeString COLLADA_ELEMENT_TIME_STEP = "time_step"; +DLLSPEC daeString COLLADA_ELEMENT_REF_ATTACHMENT = "ref_attachment"; +DLLSPEC daeString COLLADA_ELEMENT_ATTACHMENT = "attachment"; +DLLSPEC daeString COLLADA_ELEMENT_ENABLED = "enabled"; +DLLSPEC daeString COLLADA_ELEMENT_INTERPENETRATE = "interpenetrate"; +DLLSPEC daeString COLLADA_ELEMENT_LIMITS = "limits"; +DLLSPEC daeString COLLADA_ELEMENT_SPRING = "spring"; +DLLSPEC daeString COLLADA_ELEMENT_SWING_CONE_AND_TWIST = "swing_cone_and_twist"; +DLLSPEC daeString COLLADA_ELEMENT_LINEAR = "linear"; +DLLSPEC daeString COLLADA_ELEMENT_MIN = "min"; +DLLSPEC daeString COLLADA_ELEMENT_MAX = "max"; +DLLSPEC daeString COLLADA_ELEMENT_ANGULAR = "angular"; +DLLSPEC daeString COLLADA_ELEMENT_STIFFNESS = "stiffness"; +DLLSPEC daeString COLLADA_ELEMENT_DAMPING = "damping"; +DLLSPEC daeString COLLADA_ELEMENT_TARGET_VALUE = "target_value"; +DLLSPEC daeString COLLADA_ELEMENT_RIGID_BODY = "rigid_body"; +DLLSPEC daeString COLLADA_ELEMENT_RIGID_CONSTRAINT = "rigid_constraint"; + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domController.cpp b/1.4.0/dom/src/1.4/dom/domController.cpp new file mode 100644 index 0000000..4f87fe2 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domController.cpp @@ -0,0 +1,109 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domController.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domController::create(DAE& dae) +{ + domControllerRef ref = new domController(dae); + return ref; +} + + +daeMetaElement * +domController::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "controller" ); + meta->registerClass(domController::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domController,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "skin" ); + mea->setOffset( daeOffsetOf(domController,elemSkin) ); + mea->setElementType( domSkin::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "morph" ); + mea->setOffset( daeOffsetOf(domController,elemMorph) ); + mea->setElementType( domMorph::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domController,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domController,_contents)); + meta->addContentsOrder(daeOffsetOf(domController,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domController,_CMData), 1); + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domController , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domController , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domController)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domConvex_mesh.cpp b/1.4.0/dom/src/1.4/dom/domConvex_mesh.cpp new file mode 100644 index 0000000..231444c --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domConvex_mesh.cpp @@ -0,0 +1,134 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domConvex_mesh.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domConvex_mesh::create(DAE& dae) +{ + domConvex_meshRef ref = new domConvex_mesh(dae); + return ref; +} + + +daeMetaElement * +domConvex_mesh::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "convex_mesh" ); + meta->registerClass(domConvex_mesh::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 0, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, -1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domConvex_mesh,elemSource_array) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "vertices" ); + mea->setOffset( daeOffsetOf(domConvex_mesh,elemVertices) ); + mea->setElementType( domVertices::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 2, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "lines" ); + mea->setOffset( daeOffsetOf(domConvex_mesh,elemLines_array) ); + mea->setElementType( domLines::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "linestrips" ); + mea->setOffset( daeOffsetOf(domConvex_mesh,elemLinestrips_array) ); + mea->setElementType( domLinestrips::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "polygons" ); + mea->setOffset( daeOffsetOf(domConvex_mesh,elemPolygons_array) ); + mea->setElementType( domPolygons::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "polylist" ); + mea->setOffset( daeOffsetOf(domConvex_mesh,elemPolylist_array) ); + mea->setElementType( domPolylist::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "triangles" ); + mea->setOffset( daeOffsetOf(domConvex_mesh,elemTriangles_array) ); + mea->setElementType( domTriangles::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "trifans" ); + mea->setOffset( daeOffsetOf(domConvex_mesh,elemTrifans_array) ); + mea->setElementType( domTrifans::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "tristrips" ); + mea->setOffset( daeOffsetOf(domConvex_mesh,elemTristrips_array) ); + mea->setElementType( domTristrips::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3003, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domConvex_mesh,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3003 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domConvex_mesh,_contents)); + meta->addContentsOrder(daeOffsetOf(domConvex_mesh,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domConvex_mesh,_CMData), 1); + // Add attribute: convex_hull_of + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "convex_hull_of" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domConvex_mesh , attrConvex_hull_of )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domConvex_mesh)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domCylinder.cpp b/1.4.0/dom/src/1.4/dom/domCylinder.cpp new file mode 100644 index 0000000..300ecdb --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domCylinder.cpp @@ -0,0 +1,143 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCylinder.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domCylinder::create(DAE& dae) +{ + domCylinderRef ref = new domCylinder(dae); + return ref; +} + + +daeMetaElement * +domCylinder::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cylinder" ); + meta->registerClass(domCylinder::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "height" ); + mea->setOffset( daeOffsetOf(domCylinder,elemHeight) ); + mea->setElementType( domCylinder::domHeight::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "radius" ); + mea->setOffset( daeOffsetOf(domCylinder,elemRadius) ); + mea->setElementType( domCylinder::domRadius::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domCylinder,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domCylinder)); + meta->validate(); + + return meta; +} + +daeElementRef +domCylinder::domHeight::create(DAE& dae) +{ + domCylinder::domHeightRef ref = new domCylinder::domHeight(dae); + return ref; +} + + +daeMetaElement * +domCylinder::domHeight::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "height" ); + meta->registerClass(domCylinder::domHeight::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domCylinder::domHeight , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCylinder::domHeight)); + meta->validate(); + + return meta; +} + +daeElementRef +domCylinder::domRadius::create(DAE& dae) +{ + domCylinder::domRadiusRef ref = new domCylinder::domRadius(dae); + return ref; +} + + +daeMetaElement * +domCylinder::domRadius::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "radius" ); + meta->registerClass(domCylinder::domRadius::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domCylinder::domRadius , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domCylinder::domRadius)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domEffect.cpp b/1.4.0/dom/src/1.4/dom/domEffect.cpp new file mode 100644 index 0000000..9ed9d3b --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domEffect.cpp @@ -0,0 +1,148 @@ +/* + * Copyright 2006 Sony Computer Entertainment Inc. + * + * Licensed under the MIT Open Source License, for details please see license.txt or the website + * http://www.opensource.org/licenses/mit-license.php + * + */ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domEffect.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +#include <1.4/dom/domProfile_GLSL.h> +#include <1.4/dom/domProfile_COMMON.h> +#include <1.4/dom/domProfile_CG.h> +#include <1.4/dom/domProfile_GLES.h> + +namespace ColladaDOM141 { +daeElementRef +domEffect::create(DAE& dae) +{ + domEffectRef ref = new domEffect(dae); + return ref; +} + +daeMetaElement * +domEffect::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "effect" ); + meta->registerClass(domEffect::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domEffect,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domEffect,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "image" ); + mea->setOffset( daeOffsetOf(domEffect,elemImage_array) ); + mea->setElementType( domImage::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "newparam" ); + mea->setOffset( daeOffsetOf(domEffect,elemNewparam_array) ); + mea->setElementType( domFx_newparam_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 4, 1, -1 ); + mea->setName( "fx_profile_abstract" ); + mea->setOffset( daeOffsetOf(domEffect,elemFx_profile_abstract_array) ); + mea->setElementType( domFx_profile_abstract::registerElement(dae) ); + cm->appendChild( mea ); + + + mea = new daeMetaElementArrayAttribute( meta, cm, 4, 1, -1 ); + mea->setName( "profile_GLSL" ); + mea->setOffset( daeOffsetOf(domEffect,elemFx_profile_abstract_array) ); + mea->setElementType( domProfile_GLSL::registerElement(dae) ); + cm->appendChild( mea ); + + + mea = new daeMetaElementArrayAttribute( meta, cm, 4, 1, -1 ); + mea->setName( "profile_COMMON" ); + mea->setOffset( daeOffsetOf(domEffect,elemFx_profile_abstract_array) ); + mea->setElementType( domProfile_COMMON::registerElement(dae) ); + cm->appendChild( mea ); + + + mea = new daeMetaElementArrayAttribute( meta, cm, 4, 1, -1 ); + mea->setName( "profile_CG" ); + mea->setOffset( daeOffsetOf(domEffect,elemFx_profile_abstract_array) ); + mea->setElementType( domProfile_CG::registerElement(dae) ); + cm->appendChild( mea ); + + + mea = new daeMetaElementArrayAttribute( meta, cm, 4, 1, -1 ); + mea->setName( "profile_GLES" ); + mea->setOffset( daeOffsetOf(domEffect,elemFx_profile_abstract_array) ); + mea->setElementType( domProfile_GLES::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 5, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domEffect,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 5 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domEffect,_contents)); + meta->addContentsOrder(daeOffsetOf(domEffect,_contentsOrder)); + + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domEffect, attrId )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domEffect, attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domEffect)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domEllipsoid.cpp b/1.4.0/dom/src/1.4/dom/domEllipsoid.cpp new file mode 100644 index 0000000..2b98756 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domEllipsoid.cpp @@ -0,0 +1,95 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domEllipsoid.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domEllipsoid::create(DAE& dae) +{ + domEllipsoidRef ref = new domEllipsoid(dae); + return ref; +} + + +daeMetaElement * +domEllipsoid::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "ellipsoid" ); + meta->registerClass(domEllipsoid::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "size" ); + mea->setOffset( daeOffsetOf(domEllipsoid,elemSize) ); + mea->setElementType( domEllipsoid::domSize::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domEllipsoid)); + meta->validate(); + + return meta; +} + +daeElementRef +domEllipsoid::domSize::create(DAE& dae) +{ + domEllipsoid::domSizeRef ref = new domEllipsoid::domSize(dae); + return ref; +} + + +daeMetaElement * +domEllipsoid::domSize::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "size" ); + meta->registerClass(domEllipsoid::domSize::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domEllipsoid::domSize , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domEllipsoid::domSize)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domExtra.cpp b/1.4.0/dom/src/1.4/dom/domExtra.cpp new file mode 100644 index 0000000..6beebcd --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domExtra.cpp @@ -0,0 +1,98 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domExtra.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domExtra::create(DAE& dae) +{ + domExtraRef ref = new domExtra(dae); + return ref; +} + + +daeMetaElement * +domExtra::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "extra" ); + meta->registerClass(domExtra::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domExtra,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domExtra,elemTechnique_array) ); + mea->setElementType( domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domExtra , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domExtra , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: type + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "type" ); + ma->setType( dae.getAtomicTypes().get("xsNMTOKEN")); + ma->setOffset( daeOffsetOf( domExtra , attrType )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domExtra)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFloat_array.cpp b/1.4.0/dom/src/1.4/dom/domFloat_array.cpp new file mode 100644 index 0000000..4ee9351 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFloat_array.cpp @@ -0,0 +1,114 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFloat_array.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFloat_array::create(DAE& dae) +{ + domFloat_arrayRef ref = new domFloat_array(dae); + return ref; +} + + +daeMetaElement * +domFloat_array::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float_array" ); + meta->registerClass(domFloat_array::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("ListOfFloats")); + ma->setOffset( daeOffsetOf( domFloat_array , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domFloat_array , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domFloat_array , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: count + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "count" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domFloat_array , attrCount )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: digits + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "digits" ); + ma->setType( dae.getAtomicTypes().get("xsShort")); + ma->setOffset( daeOffsetOf( domFloat_array , attrDigits )); + ma->setContainer( meta ); + ma->setDefaultString( "6"); + + meta->appendAttribute(ma); + } + + // Add attribute: magnitude + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "magnitude" ); + ma->setType( dae.getAtomicTypes().get("xsShort")); + ma->setOffset( daeOffsetOf( domFloat_array , attrMagnitude )); + ma->setContainer( meta ); + ma->setDefaultString( "38"); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFloat_array)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domForce_field.cpp b/1.4.0/dom/src/1.4/dom/domForce_field.cpp new file mode 100644 index 0000000..360c1fb --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domForce_field.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domForce_field.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domForce_field::create(DAE& dae) +{ + domForce_fieldRef ref = new domForce_field(dae); + return ref; +} + + +daeMetaElement * +domForce_field::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "force_field" ); + meta->registerClass(domForce_field::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domForce_field,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domForce_field,elemTechnique_array) ); + mea->setElementType( domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domForce_field,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domForce_field , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domForce_field , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domForce_field)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_annotate_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_annotate_common.cpp new file mode 100644 index 0000000..bbbf761 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_annotate_common.cpp @@ -0,0 +1,71 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_annotate_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_annotate_common::create(DAE& dae) +{ + domFx_annotate_commonRef ref = new domFx_annotate_common(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_annotate_common" ); + meta->registerClass(domFx_annotate_common::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fx_annotate_type_common" ); + mea->setOffset( daeOffsetOf(domFx_annotate_common,elemFx_annotate_type_common) ); + mea->setElementType( domFx_annotate_type_common::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domFx_annotate_common , attrName )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_common)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_annotate_type_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_annotate_type_common.cpp new file mode 100644 index 0000000..cb76a32 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_annotate_type_common.cpp @@ -0,0 +1,730 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_annotate_type_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_annotate_type_common::create(DAE& dae) +{ + domFx_annotate_type_commonRef ref = new domFx_annotate_type_common(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_annotate_type_common" ); + meta->registerClass(domFx_annotate_type_common::create); + + meta->setIsTransparent( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemBool) ); + mea->setElementType( domFx_annotate_type_common::domBool::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool2" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemBool2) ); + mea->setElementType( domFx_annotate_type_common::domBool2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool3" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemBool3) ); + mea->setElementType( domFx_annotate_type_common::domBool3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool4" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemBool4) ); + mea->setElementType( domFx_annotate_type_common::domBool4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemInt) ); + mea->setElementType( domFx_annotate_type_common::domInt::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int2" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemInt2) ); + mea->setElementType( domFx_annotate_type_common::domInt2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int3" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemInt3) ); + mea->setElementType( domFx_annotate_type_common::domInt3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int4" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemInt4) ); + mea->setElementType( domFx_annotate_type_common::domInt4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemFloat) ); + mea->setElementType( domFx_annotate_type_common::domFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemFloat2) ); + mea->setElementType( domFx_annotate_type_common::domFloat2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemFloat3) ); + mea->setElementType( domFx_annotate_type_common::domFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemFloat4) ); + mea->setElementType( domFx_annotate_type_common::domFloat4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2x2" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemFloat2x2) ); + mea->setElementType( domFx_annotate_type_common::domFloat2x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3x3" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemFloat3x3) ); + mea->setElementType( domFx_annotate_type_common::domFloat3x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4x4" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemFloat4x4) ); + mea->setElementType( domFx_annotate_type_common::domFloat4x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "string" ); + mea->setOffset( daeOffsetOf(domFx_annotate_type_common,elemString) ); + mea->setElementType( domFx_annotate_type_common::domString::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domFx_annotate_type_common,_contents)); + meta->addContentsOrder(daeOffsetOf(domFx_annotate_type_common,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domFx_annotate_type_common,_CMData), 1); + meta->setElementSize(sizeof(domFx_annotate_type_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domBool::create(DAE& dae) +{ + domFx_annotate_type_common::domBoolRef ref = new domFx_annotate_type_common::domBool(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domBool::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool" ); + meta->registerClass(domFx_annotate_type_common::domBool::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domBool , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domBool)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domBool2::create(DAE& dae) +{ + domFx_annotate_type_common::domBool2Ref ref = new domFx_annotate_type_common::domBool2(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domBool2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool2" ); + meta->registerClass(domFx_annotate_type_common::domBool2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool2")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domBool2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domBool2)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domBool3::create(DAE& dae) +{ + domFx_annotate_type_common::domBool3Ref ref = new domFx_annotate_type_common::domBool3(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domBool3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool3" ); + meta->registerClass(domFx_annotate_type_common::domBool3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool3")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domBool3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domBool3)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domBool4::create(DAE& dae) +{ + domFx_annotate_type_common::domBool4Ref ref = new domFx_annotate_type_common::domBool4(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domBool4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool4" ); + meta->registerClass(domFx_annotate_type_common::domBool4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool4")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domBool4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domBool4)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domInt::create(DAE& dae) +{ + domFx_annotate_type_common::domIntRef ref = new domFx_annotate_type_common::domInt(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domInt::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int" ); + meta->registerClass(domFx_annotate_type_common::domInt::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Int")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domInt , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domInt)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domInt2::create(DAE& dae) +{ + domFx_annotate_type_common::domInt2Ref ref = new domFx_annotate_type_common::domInt2(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domInt2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int2" ); + meta->registerClass(domFx_annotate_type_common::domInt2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Int2")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domInt2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domInt2)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domInt3::create(DAE& dae) +{ + domFx_annotate_type_common::domInt3Ref ref = new domFx_annotate_type_common::domInt3(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domInt3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int3" ); + meta->registerClass(domFx_annotate_type_common::domInt3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Int3")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domInt3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domInt3)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domInt4::create(DAE& dae) +{ + domFx_annotate_type_common::domInt4Ref ref = new domFx_annotate_type_common::domInt4(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domInt4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int4" ); + meta->registerClass(domFx_annotate_type_common::domInt4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Int4")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domInt4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domInt4)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domFloat::create(DAE& dae) +{ + domFx_annotate_type_common::domFloatRef ref = new domFx_annotate_type_common::domFloat(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domFloat::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float" ); + meta->registerClass(domFx_annotate_type_common::domFloat::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domFloat , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domFloat)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domFloat2::create(DAE& dae) +{ + domFx_annotate_type_common::domFloat2Ref ref = new domFx_annotate_type_common::domFloat2(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domFloat2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2" ); + meta->registerClass(domFx_annotate_type_common::domFloat2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domFloat2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domFloat2)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domFloat3::create(DAE& dae) +{ + domFx_annotate_type_common::domFloat3Ref ref = new domFx_annotate_type_common::domFloat3(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domFloat3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3" ); + meta->registerClass(domFx_annotate_type_common::domFloat3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domFloat3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domFloat3)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domFloat4::create(DAE& dae) +{ + domFx_annotate_type_common::domFloat4Ref ref = new domFx_annotate_type_common::domFloat4(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domFloat4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4" ); + meta->registerClass(domFx_annotate_type_common::domFloat4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domFloat4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domFloat4)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domFloat2x2::create(DAE& dae) +{ + domFx_annotate_type_common::domFloat2x2Ref ref = new domFx_annotate_type_common::domFloat2x2(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domFloat2x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2x2" ); + meta->registerClass(domFx_annotate_type_common::domFloat2x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2x2")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domFloat2x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domFloat2x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domFloat3x3::create(DAE& dae) +{ + domFx_annotate_type_common::domFloat3x3Ref ref = new domFx_annotate_type_common::domFloat3x3(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domFloat3x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3x3" ); + meta->registerClass(domFx_annotate_type_common::domFloat3x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3x3")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domFloat3x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domFloat3x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domFloat4x4::create(DAE& dae) +{ + domFx_annotate_type_common::domFloat4x4Ref ref = new domFx_annotate_type_common::domFloat4x4(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domFloat4x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4x4" ); + meta->registerClass(domFx_annotate_type_common::domFloat4x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4x4")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domFloat4x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domFloat4x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_annotate_type_common::domString::create(DAE& dae) +{ + domFx_annotate_type_common::domStringRef ref = new domFx_annotate_type_common::domString(dae); + return ref; +} + + +daeMetaElement * +domFx_annotate_type_common::domString::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "string" ); + meta->registerClass(domFx_annotate_type_common::domString::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domFx_annotate_type_common::domString , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_annotate_type_common::domString)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_basic_type_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_basic_type_common.cpp new file mode 100644 index 0000000..72874ce --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_basic_type_common.cpp @@ -0,0 +1,1318 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_basic_type_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_basic_type_common::create(DAE& dae) +{ + domFx_basic_type_commonRef ref = new domFx_basic_type_common(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_basic_type_common" ); + meta->registerClass(domFx_basic_type_common::create); + + meta->setIsTransparent( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemBool) ); + mea->setElementType( domFx_basic_type_common::domBool::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool2" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemBool2) ); + mea->setElementType( domFx_basic_type_common::domBool2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool3" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemBool3) ); + mea->setElementType( domFx_basic_type_common::domBool3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool4" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemBool4) ); + mea->setElementType( domFx_basic_type_common::domBool4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemInt) ); + mea->setElementType( domFx_basic_type_common::domInt::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int2" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemInt2) ); + mea->setElementType( domFx_basic_type_common::domInt2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int3" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemInt3) ); + mea->setElementType( domFx_basic_type_common::domInt3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int4" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemInt4) ); + mea->setElementType( domFx_basic_type_common::domInt4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat) ); + mea->setElementType( domFx_basic_type_common::domFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat2) ); + mea->setElementType( domFx_basic_type_common::domFloat2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat3) ); + mea->setElementType( domFx_basic_type_common::domFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat4) ); + mea->setElementType( domFx_basic_type_common::domFloat4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float1x1" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat1x1) ); + mea->setElementType( domFx_basic_type_common::domFloat1x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float1x2" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat1x2) ); + mea->setElementType( domFx_basic_type_common::domFloat1x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float1x3" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat1x3) ); + mea->setElementType( domFx_basic_type_common::domFloat1x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float1x4" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat1x4) ); + mea->setElementType( domFx_basic_type_common::domFloat1x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2x1" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat2x1) ); + mea->setElementType( domFx_basic_type_common::domFloat2x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2x2" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat2x2) ); + mea->setElementType( domFx_basic_type_common::domFloat2x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2x3" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat2x3) ); + mea->setElementType( domFx_basic_type_common::domFloat2x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2x4" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat2x4) ); + mea->setElementType( domFx_basic_type_common::domFloat2x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3x1" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat3x1) ); + mea->setElementType( domFx_basic_type_common::domFloat3x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3x2" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat3x2) ); + mea->setElementType( domFx_basic_type_common::domFloat3x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3x3" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat3x3) ); + mea->setElementType( domFx_basic_type_common::domFloat3x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3x4" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat3x4) ); + mea->setElementType( domFx_basic_type_common::domFloat3x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4x1" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat4x1) ); + mea->setElementType( domFx_basic_type_common::domFloat4x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4x2" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat4x2) ); + mea->setElementType( domFx_basic_type_common::domFloat4x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4x3" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat4x3) ); + mea->setElementType( domFx_basic_type_common::domFloat4x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4x4" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemFloat4x4) ); + mea->setElementType( domFx_basic_type_common::domFloat4x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "surface" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemSurface) ); + mea->setElementType( domFx_surface_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sampler1D" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemSampler1D) ); + mea->setElementType( domFx_sampler1D_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sampler2D" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemSampler2D) ); + mea->setElementType( domFx_sampler2D_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sampler3D" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemSampler3D) ); + mea->setElementType( domFx_sampler3D_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "samplerCUBE" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemSamplerCUBE) ); + mea->setElementType( domFx_samplerCUBE_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "samplerRECT" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemSamplerRECT) ); + mea->setElementType( domFx_samplerRECT_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "samplerDEPTH" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemSamplerDEPTH) ); + mea->setElementType( domFx_samplerDEPTH_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "enum" ); + mea->setOffset( daeOffsetOf(domFx_basic_type_common,elemEnum) ); + mea->setElementType( domFx_basic_type_common::domEnum::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domFx_basic_type_common,_contents)); + meta->addContentsOrder(daeOffsetOf(domFx_basic_type_common,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domFx_basic_type_common,_CMData), 1); + meta->setElementSize(sizeof(domFx_basic_type_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domBool::create(DAE& dae) +{ + domFx_basic_type_common::domBoolRef ref = new domFx_basic_type_common::domBool(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domBool::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool" ); + meta->registerClass(domFx_basic_type_common::domBool::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domBool , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domBool)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domBool2::create(DAE& dae) +{ + domFx_basic_type_common::domBool2Ref ref = new domFx_basic_type_common::domBool2(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domBool2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool2" ); + meta->registerClass(domFx_basic_type_common::domBool2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool2")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domBool2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domBool2)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domBool3::create(DAE& dae) +{ + domFx_basic_type_common::domBool3Ref ref = new domFx_basic_type_common::domBool3(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domBool3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool3" ); + meta->registerClass(domFx_basic_type_common::domBool3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool3")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domBool3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domBool3)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domBool4::create(DAE& dae) +{ + domFx_basic_type_common::domBool4Ref ref = new domFx_basic_type_common::domBool4(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domBool4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool4" ); + meta->registerClass(domFx_basic_type_common::domBool4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool4")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domBool4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domBool4)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domInt::create(DAE& dae) +{ + domFx_basic_type_common::domIntRef ref = new domFx_basic_type_common::domInt(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domInt::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int" ); + meta->registerClass(domFx_basic_type_common::domInt::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Int")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domInt , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domInt)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domInt2::create(DAE& dae) +{ + domFx_basic_type_common::domInt2Ref ref = new domFx_basic_type_common::domInt2(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domInt2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int2" ); + meta->registerClass(domFx_basic_type_common::domInt2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Int2")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domInt2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domInt2)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domInt3::create(DAE& dae) +{ + domFx_basic_type_common::domInt3Ref ref = new domFx_basic_type_common::domInt3(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domInt3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int3" ); + meta->registerClass(domFx_basic_type_common::domInt3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Int3")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domInt3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domInt3)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domInt4::create(DAE& dae) +{ + domFx_basic_type_common::domInt4Ref ref = new domFx_basic_type_common::domInt4(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domInt4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int4" ); + meta->registerClass(domFx_basic_type_common::domInt4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Int4")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domInt4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domInt4)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat::create(DAE& dae) +{ + domFx_basic_type_common::domFloatRef ref = new domFx_basic_type_common::domFloat(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float" ); + meta->registerClass(domFx_basic_type_common::domFloat::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat2::create(DAE& dae) +{ + domFx_basic_type_common::domFloat2Ref ref = new domFx_basic_type_common::domFloat2(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2" ); + meta->registerClass(domFx_basic_type_common::domFloat2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat2)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat3::create(DAE& dae) +{ + domFx_basic_type_common::domFloat3Ref ref = new domFx_basic_type_common::domFloat3(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3" ); + meta->registerClass(domFx_basic_type_common::domFloat3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat3)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat4::create(DAE& dae) +{ + domFx_basic_type_common::domFloat4Ref ref = new domFx_basic_type_common::domFloat4(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4" ); + meta->registerClass(domFx_basic_type_common::domFloat4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat4)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat1x1::create(DAE& dae) +{ + domFx_basic_type_common::domFloat1x1Ref ref = new domFx_basic_type_common::domFloat1x1(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat1x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float1x1" ); + meta->registerClass(domFx_basic_type_common::domFloat1x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat1x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat1x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat1x2::create(DAE& dae) +{ + domFx_basic_type_common::domFloat1x2Ref ref = new domFx_basic_type_common::domFloat1x2(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat1x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float1x2" ); + meta->registerClass(domFx_basic_type_common::domFloat1x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat1x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat1x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat1x3::create(DAE& dae) +{ + domFx_basic_type_common::domFloat1x3Ref ref = new domFx_basic_type_common::domFloat1x3(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat1x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float1x3" ); + meta->registerClass(domFx_basic_type_common::domFloat1x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat1x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat1x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat1x4::create(DAE& dae) +{ + domFx_basic_type_common::domFloat1x4Ref ref = new domFx_basic_type_common::domFloat1x4(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat1x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float1x4" ); + meta->registerClass(domFx_basic_type_common::domFloat1x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat1x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat1x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat2x1::create(DAE& dae) +{ + domFx_basic_type_common::domFloat2x1Ref ref = new domFx_basic_type_common::domFloat2x1(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat2x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2x1" ); + meta->registerClass(domFx_basic_type_common::domFloat2x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat2x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat2x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat2x2::create(DAE& dae) +{ + domFx_basic_type_common::domFloat2x2Ref ref = new domFx_basic_type_common::domFloat2x2(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat2x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2x2" ); + meta->registerClass(domFx_basic_type_common::domFloat2x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2x2")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat2x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat2x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat2x3::create(DAE& dae) +{ + domFx_basic_type_common::domFloat2x3Ref ref = new domFx_basic_type_common::domFloat2x3(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat2x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2x3" ); + meta->registerClass(domFx_basic_type_common::domFloat2x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2x3")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat2x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat2x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat2x4::create(DAE& dae) +{ + domFx_basic_type_common::domFloat2x4Ref ref = new domFx_basic_type_common::domFloat2x4(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat2x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2x4" ); + meta->registerClass(domFx_basic_type_common::domFloat2x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2x4")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat2x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat2x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat3x1::create(DAE& dae) +{ + domFx_basic_type_common::domFloat3x1Ref ref = new domFx_basic_type_common::domFloat3x1(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat3x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3x1" ); + meta->registerClass(domFx_basic_type_common::domFloat3x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat3x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat3x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat3x2::create(DAE& dae) +{ + domFx_basic_type_common::domFloat3x2Ref ref = new domFx_basic_type_common::domFloat3x2(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat3x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3x2" ); + meta->registerClass(domFx_basic_type_common::domFloat3x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3x2")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat3x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat3x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat3x3::create(DAE& dae) +{ + domFx_basic_type_common::domFloat3x3Ref ref = new domFx_basic_type_common::domFloat3x3(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat3x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3x3" ); + meta->registerClass(domFx_basic_type_common::domFloat3x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3x3")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat3x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat3x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat3x4::create(DAE& dae) +{ + domFx_basic_type_common::domFloat3x4Ref ref = new domFx_basic_type_common::domFloat3x4(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat3x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3x4" ); + meta->registerClass(domFx_basic_type_common::domFloat3x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3x4")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat3x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat3x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat4x1::create(DAE& dae) +{ + domFx_basic_type_common::domFloat4x1Ref ref = new domFx_basic_type_common::domFloat4x1(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat4x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4x1" ); + meta->registerClass(domFx_basic_type_common::domFloat4x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat4x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat4x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat4x2::create(DAE& dae) +{ + domFx_basic_type_common::domFloat4x2Ref ref = new domFx_basic_type_common::domFloat4x2(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat4x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4x2" ); + meta->registerClass(domFx_basic_type_common::domFloat4x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4x2")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat4x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat4x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat4x3::create(DAE& dae) +{ + domFx_basic_type_common::domFloat4x3Ref ref = new domFx_basic_type_common::domFloat4x3(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat4x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4x3" ); + meta->registerClass(domFx_basic_type_common::domFloat4x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4x3")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat4x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat4x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domFloat4x4::create(DAE& dae) +{ + domFx_basic_type_common::domFloat4x4Ref ref = new domFx_basic_type_common::domFloat4x4(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domFloat4x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4x4" ); + meta->registerClass(domFx_basic_type_common::domFloat4x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4x4")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domFloat4x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domFloat4x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_basic_type_common::domEnum::create(DAE& dae) +{ + domFx_basic_type_common::domEnumRef ref = new domFx_basic_type_common::domEnum(dae); + return ref; +} + + +daeMetaElement * +domFx_basic_type_common::domEnum::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "enum" ); + meta->registerClass(domFx_basic_type_common::domEnum::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domFx_basic_type_common::domEnum , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_basic_type_common::domEnum)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_clearcolor_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_clearcolor_common.cpp new file mode 100644 index 0000000..e9aaf85 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_clearcolor_common.cpp @@ -0,0 +1,69 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_clearcolor_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_clearcolor_common::create(DAE& dae) +{ + domFx_clearcolor_commonRef ref = new domFx_clearcolor_common(dae); + return ref; +} + + +daeMetaElement * +domFx_clearcolor_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_clearcolor_common" ); + meta->registerClass(domFx_clearcolor_common::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_color_common")); + ma->setOffset( daeOffsetOf( domFx_clearcolor_common , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("xsNonNegativeInteger")); + ma->setOffset( daeOffsetOf( domFx_clearcolor_common , attrIndex )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_clearcolor_common)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_cleardepth_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_cleardepth_common.cpp new file mode 100644 index 0000000..c3b9320 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_cleardepth_common.cpp @@ -0,0 +1,69 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_cleardepth_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_cleardepth_common::create(DAE& dae) +{ + domFx_cleardepth_commonRef ref = new domFx_cleardepth_common(dae); + return ref; +} + + +daeMetaElement * +domFx_cleardepth_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_cleardepth_common" ); + meta->registerClass(domFx_cleardepth_common::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domFx_cleardepth_common , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("xsNonNegativeInteger")); + ma->setOffset( daeOffsetOf( domFx_cleardepth_common , attrIndex )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_cleardepth_common)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_clearstencil_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_clearstencil_common.cpp new file mode 100644 index 0000000..5a0f119 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_clearstencil_common.cpp @@ -0,0 +1,69 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_clearstencil_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_clearstencil_common::create(DAE& dae) +{ + domFx_clearstencil_commonRef ref = new domFx_clearstencil_common(dae); + return ref; +} + + +daeMetaElement * +domFx_clearstencil_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_clearstencil_common" ); + meta->registerClass(domFx_clearstencil_common::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsByte")); + ma->setOffset( daeOffsetOf( domFx_clearstencil_common , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("xsNonNegativeInteger")); + ma->setOffset( daeOffsetOf( domFx_clearstencil_common , attrIndex )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_clearstencil_common)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_code_profile.cpp b/1.4.0/dom/src/1.4/dom/domFx_code_profile.cpp new file mode 100644 index 0000000..99d2cca --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_code_profile.cpp @@ -0,0 +1,68 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_code_profile.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_code_profile::create(DAE& dae) +{ + domFx_code_profileRef ref = new domFx_code_profile(dae); + return ref; +} + + +daeMetaElement * +domFx_code_profile::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_code_profile" ); + meta->registerClass(domFx_code_profile::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domFx_code_profile , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domFx_code_profile , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_code_profile)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_colortarget_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_colortarget_common.cpp new file mode 100644 index 0000000..1e6804f --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_colortarget_common.cpp @@ -0,0 +1,108 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_colortarget_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_colortarget_common::create(DAE& dae) +{ + domFx_colortarget_commonRef ref = new domFx_colortarget_common(dae); + return ref; +} + + +daeMetaElement * +domFx_colortarget_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_colortarget_common" ); + meta->registerClass(domFx_colortarget_common::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domFx_colortarget_common , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("xsNonNegativeInteger")); + ma->setOffset( daeOffsetOf( domFx_colortarget_common , attrIndex )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: face + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "face" ); + ma->setType( dae.getAtomicTypes().get("Fx_surface_face_enum")); + ma->setOffset( daeOffsetOf( domFx_colortarget_common , attrFace )); + ma->setContainer( meta ); + ma->setDefaultString( "POSITIVE_X"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: mip + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "mip" ); + ma->setType( dae.getAtomicTypes().get("xsNonNegativeInteger")); + ma->setOffset( daeOffsetOf( domFx_colortarget_common , attrMip )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: slice + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "slice" ); + ma->setType( dae.getAtomicTypes().get("xsNonNegativeInteger")); + ma->setOffset( daeOffsetOf( domFx_colortarget_common , attrSlice )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_colortarget_common)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_depthtarget_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_depthtarget_common.cpp new file mode 100644 index 0000000..0d4df64 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_depthtarget_common.cpp @@ -0,0 +1,108 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_depthtarget_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_depthtarget_common::create(DAE& dae) +{ + domFx_depthtarget_commonRef ref = new domFx_depthtarget_common(dae); + return ref; +} + + +daeMetaElement * +domFx_depthtarget_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_depthtarget_common" ); + meta->registerClass(domFx_depthtarget_common::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domFx_depthtarget_common , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("xsNonNegativeInteger")); + ma->setOffset( daeOffsetOf( domFx_depthtarget_common , attrIndex )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: face + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "face" ); + ma->setType( dae.getAtomicTypes().get("Fx_surface_face_enum")); + ma->setOffset( daeOffsetOf( domFx_depthtarget_common , attrFace )); + ma->setContainer( meta ); + ma->setDefaultString( "POSITIVE_X"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: mip + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "mip" ); + ma->setType( dae.getAtomicTypes().get("xsNonNegativeInteger")); + ma->setOffset( daeOffsetOf( domFx_depthtarget_common , attrMip )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: slice + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "slice" ); + ma->setType( dae.getAtomicTypes().get("xsNonNegativeInteger")); + ma->setOffset( daeOffsetOf( domFx_depthtarget_common , attrSlice )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_depthtarget_common)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_include_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_include_common.cpp new file mode 100644 index 0000000..c17c446 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_include_common.cpp @@ -0,0 +1,71 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_include_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_include_common::create(DAE& dae) +{ + domFx_include_commonRef ref = new domFx_include_common(dae); + return ref; +} + + +daeMetaElement * +domFx_include_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_include_common" ); + meta->registerClass(domFx_include_common::create); + + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domFx_include_common , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: url + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "url" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domFx_include_common , attrUrl )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_include_common)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_newparam_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_newparam_common.cpp new file mode 100644 index 0000000..5247cee --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_newparam_common.cpp @@ -0,0 +1,161 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_newparam_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_newparam_common::create(DAE& dae) +{ + domFx_newparam_commonRef ref = new domFx_newparam_common(dae); + return ref; +} + + +daeMetaElement * +domFx_newparam_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_newparam_common" ); + meta->registerClass(domFx_newparam_common::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domFx_newparam_common,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "semantic" ); + mea->setOffset( daeOffsetOf(domFx_newparam_common,elemSemantic) ); + mea->setElementType( domFx_newparam_common::domSemantic::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "modifier" ); + mea->setOffset( daeOffsetOf(domFx_newparam_common,elemModifier) ); + mea->setElementType( domFx_newparam_common::domModifier::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 1, 1 ); + mea->setName( "fx_basic_type_common" ); + mea->setOffset( daeOffsetOf(domFx_newparam_common,elemFx_basic_type_common) ); + mea->setElementType( domFx_basic_type_common::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 3, 1, 1 ) ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domFx_newparam_common , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_newparam_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_newparam_common::domSemantic::create(DAE& dae) +{ + domFx_newparam_common::domSemanticRef ref = new domFx_newparam_common::domSemantic(dae); + return ref; +} + + +daeMetaElement * +domFx_newparam_common::domSemantic::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "semantic" ); + meta->registerClass(domFx_newparam_common::domSemantic::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domFx_newparam_common::domSemantic , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_newparam_common::domSemantic)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_newparam_common::domModifier::create(DAE& dae) +{ + domFx_newparam_common::domModifierRef ref = new domFx_newparam_common::domModifier(dae); + return ref; +} + + +daeMetaElement * +domFx_newparam_common::domModifier::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "modifier" ); + meta->registerClass(domFx_newparam_common::domModifier::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_modifier_enum_common")); + ma->setOffset( daeOffsetOf( domFx_newparam_common::domModifier , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_newparam_common::domModifier)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_profile_abstract.cpp b/1.4.0/dom/src/1.4/dom/domFx_profile_abstract.cpp new file mode 100644 index 0000000..a0380d6 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_profile_abstract.cpp @@ -0,0 +1,48 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_profile_abstract.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_profile_abstract::create(DAE& dae) +{ + domFx_profile_abstractRef ref = new domFx_profile_abstract(dae); + return ref; +} + + +daeMetaElement * +domFx_profile_abstract::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_profile_abstract" ); + meta->registerClass(domFx_profile_abstract::create); + + meta->setIsAbstract( true ); + + meta->setElementSize(sizeof(domFx_profile_abstract)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_sampler1D_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_sampler1D_common.cpp new file mode 100644 index 0000000..15b8d04 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_sampler1D_common.cpp @@ -0,0 +1,395 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_sampler1D_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_sampler1D_common::create(DAE& dae) +{ + domFx_sampler1D_commonRef ref = new domFx_sampler1D_common(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler1D_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_sampler1D_common" ); + meta->registerClass(domFx_sampler1D_common::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domFx_sampler1D_common,elemSource) ); + mea->setElementType( domFx_sampler1D_common::domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domFx_sampler1D_common,elemWrap_s) ); + mea->setElementType( domFx_sampler1D_common::domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domFx_sampler1D_common,elemMinfilter) ); + mea->setElementType( domFx_sampler1D_common::domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domFx_sampler1D_common,elemMagfilter) ); + mea->setElementType( domFx_sampler1D_common::domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domFx_sampler1D_common,elemMipfilter) ); + mea->setElementType( domFx_sampler1D_common::domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "border_color" ); + mea->setOffset( daeOffsetOf(domFx_sampler1D_common,elemBorder_color) ); + mea->setElementType( domFx_sampler1D_common::domBorder_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domFx_sampler1D_common,elemMipmap_maxlevel) ); + mea->setElementType( domFx_sampler1D_common::domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domFx_sampler1D_common,elemMipmap_bias) ); + mea->setElementType( domFx_sampler1D_common::domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 8, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domFx_sampler1D_common,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 8 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domFx_sampler1D_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler1D_common::domSource::create(DAE& dae) +{ + domFx_sampler1D_common::domSourceRef ref = new domFx_sampler1D_common::domSource(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler1D_common::domSource::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "source" ); + meta->registerClass(domFx_sampler1D_common::domSource::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domFx_sampler1D_common::domSource , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler1D_common::domSource)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler1D_common::domWrap_s::create(DAE& dae) +{ + domFx_sampler1D_common::domWrap_sRef ref = new domFx_sampler1D_common::domWrap_s(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler1D_common::domWrap_s::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "wrap_s" ); + meta->registerClass(domFx_sampler1D_common::domWrap_s::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_wrap_common")); + ma->setOffset( daeOffsetOf( domFx_sampler1D_common::domWrap_s , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler1D_common::domWrap_s)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler1D_common::domMinfilter::create(DAE& dae) +{ + domFx_sampler1D_common::domMinfilterRef ref = new domFx_sampler1D_common::domMinfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler1D_common::domMinfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "minfilter" ); + meta->registerClass(domFx_sampler1D_common::domMinfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_sampler1D_common::domMinfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler1D_common::domMinfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler1D_common::domMagfilter::create(DAE& dae) +{ + domFx_sampler1D_common::domMagfilterRef ref = new domFx_sampler1D_common::domMagfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler1D_common::domMagfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "magfilter" ); + meta->registerClass(domFx_sampler1D_common::domMagfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_sampler1D_common::domMagfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler1D_common::domMagfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler1D_common::domMipfilter::create(DAE& dae) +{ + domFx_sampler1D_common::domMipfilterRef ref = new domFx_sampler1D_common::domMipfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler1D_common::domMipfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipfilter" ); + meta->registerClass(domFx_sampler1D_common::domMipfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_sampler1D_common::domMipfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler1D_common::domMipfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler1D_common::domBorder_color::create(DAE& dae) +{ + domFx_sampler1D_common::domBorder_colorRef ref = new domFx_sampler1D_common::domBorder_color(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler1D_common::domBorder_color::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "border_color" ); + meta->registerClass(domFx_sampler1D_common::domBorder_color::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_color_common")); + ma->setOffset( daeOffsetOf( domFx_sampler1D_common::domBorder_color , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler1D_common::domBorder_color)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler1D_common::domMipmap_maxlevel::create(DAE& dae) +{ + domFx_sampler1D_common::domMipmap_maxlevelRef ref = new domFx_sampler1D_common::domMipmap_maxlevel(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler1D_common::domMipmap_maxlevel::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipmap_maxlevel" ); + meta->registerClass(domFx_sampler1D_common::domMipmap_maxlevel::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedByte")); + ma->setOffset( daeOffsetOf( domFx_sampler1D_common::domMipmap_maxlevel , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler1D_common::domMipmap_maxlevel)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler1D_common::domMipmap_bias::create(DAE& dae) +{ + domFx_sampler1D_common::domMipmap_biasRef ref = new domFx_sampler1D_common::domMipmap_bias(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler1D_common::domMipmap_bias::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipmap_bias" ); + meta->registerClass(domFx_sampler1D_common::domMipmap_bias::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsFloat")); + ma->setOffset( daeOffsetOf( domFx_sampler1D_common::domMipmap_bias , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler1D_common::domMipmap_bias)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_sampler2D_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_sampler2D_common.cpp new file mode 100644 index 0000000..b73133a --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_sampler2D_common.cpp @@ -0,0 +1,437 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_sampler2D_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_sampler2D_common::create(DAE& dae) +{ + domFx_sampler2D_commonRef ref = new domFx_sampler2D_common(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler2D_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_sampler2D_common" ); + meta->registerClass(domFx_sampler2D_common::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domFx_sampler2D_common,elemSource) ); + mea->setElementType( domFx_sampler2D_common::domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domFx_sampler2D_common,elemWrap_s) ); + mea->setElementType( domFx_sampler2D_common::domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domFx_sampler2D_common,elemWrap_t) ); + mea->setElementType( domFx_sampler2D_common::domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domFx_sampler2D_common,elemMinfilter) ); + mea->setElementType( domFx_sampler2D_common::domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domFx_sampler2D_common,elemMagfilter) ); + mea->setElementType( domFx_sampler2D_common::domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domFx_sampler2D_common,elemMipfilter) ); + mea->setElementType( domFx_sampler2D_common::domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "border_color" ); + mea->setOffset( daeOffsetOf(domFx_sampler2D_common,elemBorder_color) ); + mea->setElementType( domFx_sampler2D_common::domBorder_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domFx_sampler2D_common,elemMipmap_maxlevel) ); + mea->setElementType( domFx_sampler2D_common::domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 8, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domFx_sampler2D_common,elemMipmap_bias) ); + mea->setElementType( domFx_sampler2D_common::domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 9, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domFx_sampler2D_common,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 9 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domFx_sampler2D_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler2D_common::domSource::create(DAE& dae) +{ + domFx_sampler2D_common::domSourceRef ref = new domFx_sampler2D_common::domSource(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler2D_common::domSource::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "source" ); + meta->registerClass(domFx_sampler2D_common::domSource::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domFx_sampler2D_common::domSource , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler2D_common::domSource)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler2D_common::domWrap_s::create(DAE& dae) +{ + domFx_sampler2D_common::domWrap_sRef ref = new domFx_sampler2D_common::domWrap_s(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler2D_common::domWrap_s::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "wrap_s" ); + meta->registerClass(domFx_sampler2D_common::domWrap_s::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_wrap_common")); + ma->setOffset( daeOffsetOf( domFx_sampler2D_common::domWrap_s , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler2D_common::domWrap_s)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler2D_common::domWrap_t::create(DAE& dae) +{ + domFx_sampler2D_common::domWrap_tRef ref = new domFx_sampler2D_common::domWrap_t(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler2D_common::domWrap_t::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "wrap_t" ); + meta->registerClass(domFx_sampler2D_common::domWrap_t::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_wrap_common")); + ma->setOffset( daeOffsetOf( domFx_sampler2D_common::domWrap_t , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler2D_common::domWrap_t)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler2D_common::domMinfilter::create(DAE& dae) +{ + domFx_sampler2D_common::domMinfilterRef ref = new domFx_sampler2D_common::domMinfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler2D_common::domMinfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "minfilter" ); + meta->registerClass(domFx_sampler2D_common::domMinfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_sampler2D_common::domMinfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler2D_common::domMinfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler2D_common::domMagfilter::create(DAE& dae) +{ + domFx_sampler2D_common::domMagfilterRef ref = new domFx_sampler2D_common::domMagfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler2D_common::domMagfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "magfilter" ); + meta->registerClass(domFx_sampler2D_common::domMagfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_sampler2D_common::domMagfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler2D_common::domMagfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler2D_common::domMipfilter::create(DAE& dae) +{ + domFx_sampler2D_common::domMipfilterRef ref = new domFx_sampler2D_common::domMipfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler2D_common::domMipfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipfilter" ); + meta->registerClass(domFx_sampler2D_common::domMipfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_sampler2D_common::domMipfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler2D_common::domMipfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler2D_common::domBorder_color::create(DAE& dae) +{ + domFx_sampler2D_common::domBorder_colorRef ref = new domFx_sampler2D_common::domBorder_color(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler2D_common::domBorder_color::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "border_color" ); + meta->registerClass(domFx_sampler2D_common::domBorder_color::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_color_common")); + ma->setOffset( daeOffsetOf( domFx_sampler2D_common::domBorder_color , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler2D_common::domBorder_color)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler2D_common::domMipmap_maxlevel::create(DAE& dae) +{ + domFx_sampler2D_common::domMipmap_maxlevelRef ref = new domFx_sampler2D_common::domMipmap_maxlevel(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler2D_common::domMipmap_maxlevel::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipmap_maxlevel" ); + meta->registerClass(domFx_sampler2D_common::domMipmap_maxlevel::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedByte")); + ma->setOffset( daeOffsetOf( domFx_sampler2D_common::domMipmap_maxlevel , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler2D_common::domMipmap_maxlevel)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler2D_common::domMipmap_bias::create(DAE& dae) +{ + domFx_sampler2D_common::domMipmap_biasRef ref = new domFx_sampler2D_common::domMipmap_bias(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler2D_common::domMipmap_bias::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipmap_bias" ); + meta->registerClass(domFx_sampler2D_common::domMipmap_bias::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsFloat")); + ma->setOffset( daeOffsetOf( domFx_sampler2D_common::domMipmap_bias , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler2D_common::domMipmap_bias)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_sampler3D_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_sampler3D_common.cpp new file mode 100644 index 0000000..c60c68f --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_sampler3D_common.cpp @@ -0,0 +1,479 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_sampler3D_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_sampler3D_common::create(DAE& dae) +{ + domFx_sampler3D_commonRef ref = new domFx_sampler3D_common(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler3D_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_sampler3D_common" ); + meta->registerClass(domFx_sampler3D_common::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domFx_sampler3D_common,elemSource) ); + mea->setElementType( domFx_sampler3D_common::domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domFx_sampler3D_common,elemWrap_s) ); + mea->setElementType( domFx_sampler3D_common::domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domFx_sampler3D_common,elemWrap_t) ); + mea->setElementType( domFx_sampler3D_common::domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "wrap_p" ); + mea->setOffset( daeOffsetOf(domFx_sampler3D_common,elemWrap_p) ); + mea->setElementType( domFx_sampler3D_common::domWrap_p::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domFx_sampler3D_common,elemMinfilter) ); + mea->setElementType( domFx_sampler3D_common::domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domFx_sampler3D_common,elemMagfilter) ); + mea->setElementType( domFx_sampler3D_common::domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domFx_sampler3D_common,elemMipfilter) ); + mea->setElementType( domFx_sampler3D_common::domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "border_color" ); + mea->setOffset( daeOffsetOf(domFx_sampler3D_common,elemBorder_color) ); + mea->setElementType( domFx_sampler3D_common::domBorder_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 8, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domFx_sampler3D_common,elemMipmap_maxlevel) ); + mea->setElementType( domFx_sampler3D_common::domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 9, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domFx_sampler3D_common,elemMipmap_bias) ); + mea->setElementType( domFx_sampler3D_common::domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 10, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domFx_sampler3D_common,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 10 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domFx_sampler3D_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler3D_common::domSource::create(DAE& dae) +{ + domFx_sampler3D_common::domSourceRef ref = new domFx_sampler3D_common::domSource(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler3D_common::domSource::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "source" ); + meta->registerClass(domFx_sampler3D_common::domSource::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domFx_sampler3D_common::domSource , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler3D_common::domSource)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler3D_common::domWrap_s::create(DAE& dae) +{ + domFx_sampler3D_common::domWrap_sRef ref = new domFx_sampler3D_common::domWrap_s(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler3D_common::domWrap_s::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "wrap_s" ); + meta->registerClass(domFx_sampler3D_common::domWrap_s::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_wrap_common")); + ma->setOffset( daeOffsetOf( domFx_sampler3D_common::domWrap_s , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler3D_common::domWrap_s)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler3D_common::domWrap_t::create(DAE& dae) +{ + domFx_sampler3D_common::domWrap_tRef ref = new domFx_sampler3D_common::domWrap_t(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler3D_common::domWrap_t::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "wrap_t" ); + meta->registerClass(domFx_sampler3D_common::domWrap_t::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_wrap_common")); + ma->setOffset( daeOffsetOf( domFx_sampler3D_common::domWrap_t , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler3D_common::domWrap_t)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler3D_common::domWrap_p::create(DAE& dae) +{ + domFx_sampler3D_common::domWrap_pRef ref = new domFx_sampler3D_common::domWrap_p(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler3D_common::domWrap_p::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "wrap_p" ); + meta->registerClass(domFx_sampler3D_common::domWrap_p::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_wrap_common")); + ma->setOffset( daeOffsetOf( domFx_sampler3D_common::domWrap_p , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler3D_common::domWrap_p)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler3D_common::domMinfilter::create(DAE& dae) +{ + domFx_sampler3D_common::domMinfilterRef ref = new domFx_sampler3D_common::domMinfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler3D_common::domMinfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "minfilter" ); + meta->registerClass(domFx_sampler3D_common::domMinfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_sampler3D_common::domMinfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler3D_common::domMinfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler3D_common::domMagfilter::create(DAE& dae) +{ + domFx_sampler3D_common::domMagfilterRef ref = new domFx_sampler3D_common::domMagfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler3D_common::domMagfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "magfilter" ); + meta->registerClass(domFx_sampler3D_common::domMagfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_sampler3D_common::domMagfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler3D_common::domMagfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler3D_common::domMipfilter::create(DAE& dae) +{ + domFx_sampler3D_common::domMipfilterRef ref = new domFx_sampler3D_common::domMipfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler3D_common::domMipfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipfilter" ); + meta->registerClass(domFx_sampler3D_common::domMipfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_sampler3D_common::domMipfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler3D_common::domMipfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler3D_common::domBorder_color::create(DAE& dae) +{ + domFx_sampler3D_common::domBorder_colorRef ref = new domFx_sampler3D_common::domBorder_color(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler3D_common::domBorder_color::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "border_color" ); + meta->registerClass(domFx_sampler3D_common::domBorder_color::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_color_common")); + ma->setOffset( daeOffsetOf( domFx_sampler3D_common::domBorder_color , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler3D_common::domBorder_color)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler3D_common::domMipmap_maxlevel::create(DAE& dae) +{ + domFx_sampler3D_common::domMipmap_maxlevelRef ref = new domFx_sampler3D_common::domMipmap_maxlevel(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler3D_common::domMipmap_maxlevel::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipmap_maxlevel" ); + meta->registerClass(domFx_sampler3D_common::domMipmap_maxlevel::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedByte")); + ma->setOffset( daeOffsetOf( domFx_sampler3D_common::domMipmap_maxlevel , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler3D_common::domMipmap_maxlevel)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_sampler3D_common::domMipmap_bias::create(DAE& dae) +{ + domFx_sampler3D_common::domMipmap_biasRef ref = new domFx_sampler3D_common::domMipmap_bias(dae); + return ref; +} + + +daeMetaElement * +domFx_sampler3D_common::domMipmap_bias::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipmap_bias" ); + meta->registerClass(domFx_sampler3D_common::domMipmap_bias::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsFloat")); + ma->setOffset( daeOffsetOf( domFx_sampler3D_common::domMipmap_bias , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_sampler3D_common::domMipmap_bias)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_samplerCUBE_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_samplerCUBE_common.cpp new file mode 100644 index 0000000..2241149 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_samplerCUBE_common.cpp @@ -0,0 +1,479 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_samplerCUBE_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_samplerCUBE_common::create(DAE& dae) +{ + domFx_samplerCUBE_commonRef ref = new domFx_samplerCUBE_common(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerCUBE_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_samplerCUBE_common" ); + meta->registerClass(domFx_samplerCUBE_common::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domFx_samplerCUBE_common,elemSource) ); + mea->setElementType( domFx_samplerCUBE_common::domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domFx_samplerCUBE_common,elemWrap_s) ); + mea->setElementType( domFx_samplerCUBE_common::domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domFx_samplerCUBE_common,elemWrap_t) ); + mea->setElementType( domFx_samplerCUBE_common::domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "wrap_p" ); + mea->setOffset( daeOffsetOf(domFx_samplerCUBE_common,elemWrap_p) ); + mea->setElementType( domFx_samplerCUBE_common::domWrap_p::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domFx_samplerCUBE_common,elemMinfilter) ); + mea->setElementType( domFx_samplerCUBE_common::domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domFx_samplerCUBE_common,elemMagfilter) ); + mea->setElementType( domFx_samplerCUBE_common::domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domFx_samplerCUBE_common,elemMipfilter) ); + mea->setElementType( domFx_samplerCUBE_common::domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "border_color" ); + mea->setOffset( daeOffsetOf(domFx_samplerCUBE_common,elemBorder_color) ); + mea->setElementType( domFx_samplerCUBE_common::domBorder_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 8, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domFx_samplerCUBE_common,elemMipmap_maxlevel) ); + mea->setElementType( domFx_samplerCUBE_common::domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 9, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domFx_samplerCUBE_common,elemMipmap_bias) ); + mea->setElementType( domFx_samplerCUBE_common::domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 10, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domFx_samplerCUBE_common,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 10 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domFx_samplerCUBE_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerCUBE_common::domSource::create(DAE& dae) +{ + domFx_samplerCUBE_common::domSourceRef ref = new domFx_samplerCUBE_common::domSource(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerCUBE_common::domSource::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "source" ); + meta->registerClass(domFx_samplerCUBE_common::domSource::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domFx_samplerCUBE_common::domSource , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerCUBE_common::domSource)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerCUBE_common::domWrap_s::create(DAE& dae) +{ + domFx_samplerCUBE_common::domWrap_sRef ref = new domFx_samplerCUBE_common::domWrap_s(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerCUBE_common::domWrap_s::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "wrap_s" ); + meta->registerClass(domFx_samplerCUBE_common::domWrap_s::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_wrap_common")); + ma->setOffset( daeOffsetOf( domFx_samplerCUBE_common::domWrap_s , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerCUBE_common::domWrap_s)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerCUBE_common::domWrap_t::create(DAE& dae) +{ + domFx_samplerCUBE_common::domWrap_tRef ref = new domFx_samplerCUBE_common::domWrap_t(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerCUBE_common::domWrap_t::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "wrap_t" ); + meta->registerClass(domFx_samplerCUBE_common::domWrap_t::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_wrap_common")); + ma->setOffset( daeOffsetOf( domFx_samplerCUBE_common::domWrap_t , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerCUBE_common::domWrap_t)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerCUBE_common::domWrap_p::create(DAE& dae) +{ + domFx_samplerCUBE_common::domWrap_pRef ref = new domFx_samplerCUBE_common::domWrap_p(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerCUBE_common::domWrap_p::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "wrap_p" ); + meta->registerClass(domFx_samplerCUBE_common::domWrap_p::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_wrap_common")); + ma->setOffset( daeOffsetOf( domFx_samplerCUBE_common::domWrap_p , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerCUBE_common::domWrap_p)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerCUBE_common::domMinfilter::create(DAE& dae) +{ + domFx_samplerCUBE_common::domMinfilterRef ref = new domFx_samplerCUBE_common::domMinfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerCUBE_common::domMinfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "minfilter" ); + meta->registerClass(domFx_samplerCUBE_common::domMinfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_samplerCUBE_common::domMinfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerCUBE_common::domMinfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerCUBE_common::domMagfilter::create(DAE& dae) +{ + domFx_samplerCUBE_common::domMagfilterRef ref = new domFx_samplerCUBE_common::domMagfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerCUBE_common::domMagfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "magfilter" ); + meta->registerClass(domFx_samplerCUBE_common::domMagfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_samplerCUBE_common::domMagfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerCUBE_common::domMagfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerCUBE_common::domMipfilter::create(DAE& dae) +{ + domFx_samplerCUBE_common::domMipfilterRef ref = new domFx_samplerCUBE_common::domMipfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerCUBE_common::domMipfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipfilter" ); + meta->registerClass(domFx_samplerCUBE_common::domMipfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_samplerCUBE_common::domMipfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerCUBE_common::domMipfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerCUBE_common::domBorder_color::create(DAE& dae) +{ + domFx_samplerCUBE_common::domBorder_colorRef ref = new domFx_samplerCUBE_common::domBorder_color(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerCUBE_common::domBorder_color::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "border_color" ); + meta->registerClass(domFx_samplerCUBE_common::domBorder_color::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_color_common")); + ma->setOffset( daeOffsetOf( domFx_samplerCUBE_common::domBorder_color , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerCUBE_common::domBorder_color)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerCUBE_common::domMipmap_maxlevel::create(DAE& dae) +{ + domFx_samplerCUBE_common::domMipmap_maxlevelRef ref = new domFx_samplerCUBE_common::domMipmap_maxlevel(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerCUBE_common::domMipmap_maxlevel::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipmap_maxlevel" ); + meta->registerClass(domFx_samplerCUBE_common::domMipmap_maxlevel::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedByte")); + ma->setOffset( daeOffsetOf( domFx_samplerCUBE_common::domMipmap_maxlevel , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerCUBE_common::domMipmap_maxlevel)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerCUBE_common::domMipmap_bias::create(DAE& dae) +{ + domFx_samplerCUBE_common::domMipmap_biasRef ref = new domFx_samplerCUBE_common::domMipmap_bias(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerCUBE_common::domMipmap_bias::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipmap_bias" ); + meta->registerClass(domFx_samplerCUBE_common::domMipmap_bias::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsFloat")); + ma->setOffset( daeOffsetOf( domFx_samplerCUBE_common::domMipmap_bias , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerCUBE_common::domMipmap_bias)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_samplerDEPTH_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_samplerDEPTH_common.cpp new file mode 100644 index 0000000..e263902 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_samplerDEPTH_common.cpp @@ -0,0 +1,269 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_samplerDEPTH_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_samplerDEPTH_common::create(DAE& dae) +{ + domFx_samplerDEPTH_commonRef ref = new domFx_samplerDEPTH_common(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerDEPTH_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_samplerDEPTH_common" ); + meta->registerClass(domFx_samplerDEPTH_common::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domFx_samplerDEPTH_common,elemSource) ); + mea->setElementType( domFx_samplerDEPTH_common::domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domFx_samplerDEPTH_common,elemWrap_s) ); + mea->setElementType( domFx_samplerDEPTH_common::domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domFx_samplerDEPTH_common,elemWrap_t) ); + mea->setElementType( domFx_samplerDEPTH_common::domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domFx_samplerDEPTH_common,elemMinfilter) ); + mea->setElementType( domFx_samplerDEPTH_common::domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domFx_samplerDEPTH_common,elemMagfilter) ); + mea->setElementType( domFx_samplerDEPTH_common::domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 5, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domFx_samplerDEPTH_common,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 5 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domFx_samplerDEPTH_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerDEPTH_common::domSource::create(DAE& dae) +{ + domFx_samplerDEPTH_common::domSourceRef ref = new domFx_samplerDEPTH_common::domSource(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerDEPTH_common::domSource::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "source" ); + meta->registerClass(domFx_samplerDEPTH_common::domSource::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domFx_samplerDEPTH_common::domSource , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerDEPTH_common::domSource)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerDEPTH_common::domWrap_s::create(DAE& dae) +{ + domFx_samplerDEPTH_common::domWrap_sRef ref = new domFx_samplerDEPTH_common::domWrap_s(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerDEPTH_common::domWrap_s::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "wrap_s" ); + meta->registerClass(domFx_samplerDEPTH_common::domWrap_s::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_wrap_common")); + ma->setOffset( daeOffsetOf( domFx_samplerDEPTH_common::domWrap_s , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerDEPTH_common::domWrap_s)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerDEPTH_common::domWrap_t::create(DAE& dae) +{ + domFx_samplerDEPTH_common::domWrap_tRef ref = new domFx_samplerDEPTH_common::domWrap_t(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerDEPTH_common::domWrap_t::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "wrap_t" ); + meta->registerClass(domFx_samplerDEPTH_common::domWrap_t::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_wrap_common")); + ma->setOffset( daeOffsetOf( domFx_samplerDEPTH_common::domWrap_t , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerDEPTH_common::domWrap_t)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerDEPTH_common::domMinfilter::create(DAE& dae) +{ + domFx_samplerDEPTH_common::domMinfilterRef ref = new domFx_samplerDEPTH_common::domMinfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerDEPTH_common::domMinfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "minfilter" ); + meta->registerClass(domFx_samplerDEPTH_common::domMinfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_samplerDEPTH_common::domMinfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerDEPTH_common::domMinfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerDEPTH_common::domMagfilter::create(DAE& dae) +{ + domFx_samplerDEPTH_common::domMagfilterRef ref = new domFx_samplerDEPTH_common::domMagfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerDEPTH_common::domMagfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "magfilter" ); + meta->registerClass(domFx_samplerDEPTH_common::domMagfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_samplerDEPTH_common::domMagfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerDEPTH_common::domMagfilter)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_samplerRECT_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_samplerRECT_common.cpp new file mode 100644 index 0000000..2f6717b --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_samplerRECT_common.cpp @@ -0,0 +1,437 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_samplerRECT_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_samplerRECT_common::create(DAE& dae) +{ + domFx_samplerRECT_commonRef ref = new domFx_samplerRECT_common(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerRECT_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_samplerRECT_common" ); + meta->registerClass(domFx_samplerRECT_common::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domFx_samplerRECT_common,elemSource) ); + mea->setElementType( domFx_samplerRECT_common::domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domFx_samplerRECT_common,elemWrap_s) ); + mea->setElementType( domFx_samplerRECT_common::domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domFx_samplerRECT_common,elemWrap_t) ); + mea->setElementType( domFx_samplerRECT_common::domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domFx_samplerRECT_common,elemMinfilter) ); + mea->setElementType( domFx_samplerRECT_common::domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domFx_samplerRECT_common,elemMagfilter) ); + mea->setElementType( domFx_samplerRECT_common::domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domFx_samplerRECT_common,elemMipfilter) ); + mea->setElementType( domFx_samplerRECT_common::domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "border_color" ); + mea->setOffset( daeOffsetOf(domFx_samplerRECT_common,elemBorder_color) ); + mea->setElementType( domFx_samplerRECT_common::domBorder_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domFx_samplerRECT_common,elemMipmap_maxlevel) ); + mea->setElementType( domFx_samplerRECT_common::domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 8, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domFx_samplerRECT_common,elemMipmap_bias) ); + mea->setElementType( domFx_samplerRECT_common::domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 9, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domFx_samplerRECT_common,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 9 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domFx_samplerRECT_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerRECT_common::domSource::create(DAE& dae) +{ + domFx_samplerRECT_common::domSourceRef ref = new domFx_samplerRECT_common::domSource(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerRECT_common::domSource::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "source" ); + meta->registerClass(domFx_samplerRECT_common::domSource::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domFx_samplerRECT_common::domSource , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerRECT_common::domSource)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerRECT_common::domWrap_s::create(DAE& dae) +{ + domFx_samplerRECT_common::domWrap_sRef ref = new domFx_samplerRECT_common::domWrap_s(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerRECT_common::domWrap_s::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "wrap_s" ); + meta->registerClass(domFx_samplerRECT_common::domWrap_s::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_wrap_common")); + ma->setOffset( daeOffsetOf( domFx_samplerRECT_common::domWrap_s , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerRECT_common::domWrap_s)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerRECT_common::domWrap_t::create(DAE& dae) +{ + domFx_samplerRECT_common::domWrap_tRef ref = new domFx_samplerRECT_common::domWrap_t(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerRECT_common::domWrap_t::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "wrap_t" ); + meta->registerClass(domFx_samplerRECT_common::domWrap_t::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_wrap_common")); + ma->setOffset( daeOffsetOf( domFx_samplerRECT_common::domWrap_t , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerRECT_common::domWrap_t)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerRECT_common::domMinfilter::create(DAE& dae) +{ + domFx_samplerRECT_common::domMinfilterRef ref = new domFx_samplerRECT_common::domMinfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerRECT_common::domMinfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "minfilter" ); + meta->registerClass(domFx_samplerRECT_common::domMinfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_samplerRECT_common::domMinfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerRECT_common::domMinfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerRECT_common::domMagfilter::create(DAE& dae) +{ + domFx_samplerRECT_common::domMagfilterRef ref = new domFx_samplerRECT_common::domMagfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerRECT_common::domMagfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "magfilter" ); + meta->registerClass(domFx_samplerRECT_common::domMagfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_samplerRECT_common::domMagfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerRECT_common::domMagfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerRECT_common::domMipfilter::create(DAE& dae) +{ + domFx_samplerRECT_common::domMipfilterRef ref = new domFx_samplerRECT_common::domMipfilter(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerRECT_common::domMipfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipfilter" ); + meta->registerClass(domFx_samplerRECT_common::domMipfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domFx_samplerRECT_common::domMipfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerRECT_common::domMipfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerRECT_common::domBorder_color::create(DAE& dae) +{ + domFx_samplerRECT_common::domBorder_colorRef ref = new domFx_samplerRECT_common::domBorder_color(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerRECT_common::domBorder_color::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "border_color" ); + meta->registerClass(domFx_samplerRECT_common::domBorder_color::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_color_common")); + ma->setOffset( daeOffsetOf( domFx_samplerRECT_common::domBorder_color , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerRECT_common::domBorder_color)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerRECT_common::domMipmap_maxlevel::create(DAE& dae) +{ + domFx_samplerRECT_common::domMipmap_maxlevelRef ref = new domFx_samplerRECT_common::domMipmap_maxlevel(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerRECT_common::domMipmap_maxlevel::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipmap_maxlevel" ); + meta->registerClass(domFx_samplerRECT_common::domMipmap_maxlevel::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedByte")); + ma->setOffset( daeOffsetOf( domFx_samplerRECT_common::domMipmap_maxlevel , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerRECT_common::domMipmap_maxlevel)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_samplerRECT_common::domMipmap_bias::create(DAE& dae) +{ + domFx_samplerRECT_common::domMipmap_biasRef ref = new domFx_samplerRECT_common::domMipmap_bias(dae); + return ref; +} + + +daeMetaElement * +domFx_samplerRECT_common::domMipmap_bias::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipmap_bias" ); + meta->registerClass(domFx_samplerRECT_common::domMipmap_bias::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsFloat")); + ma->setOffset( daeOffsetOf( domFx_samplerRECT_common::domMipmap_bias , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_samplerRECT_common::domMipmap_bias)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_stenciltarget_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_stenciltarget_common.cpp new file mode 100644 index 0000000..0abe4c3 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_stenciltarget_common.cpp @@ -0,0 +1,108 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_stenciltarget_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_stenciltarget_common::create(DAE& dae) +{ + domFx_stenciltarget_commonRef ref = new domFx_stenciltarget_common(dae); + return ref; +} + + +daeMetaElement * +domFx_stenciltarget_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_stenciltarget_common" ); + meta->registerClass(domFx_stenciltarget_common::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domFx_stenciltarget_common , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("xsNonNegativeInteger")); + ma->setOffset( daeOffsetOf( domFx_stenciltarget_common , attrIndex )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: face + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "face" ); + ma->setType( dae.getAtomicTypes().get("Fx_surface_face_enum")); + ma->setOffset( daeOffsetOf( domFx_stenciltarget_common , attrFace )); + ma->setContainer( meta ); + ma->setDefaultString( "POSITIVE_X"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: mip + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "mip" ); + ma->setType( dae.getAtomicTypes().get("xsNonNegativeInteger")); + ma->setOffset( daeOffsetOf( domFx_stenciltarget_common , attrMip )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: slice + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "slice" ); + ma->setType( dae.getAtomicTypes().get("xsNonNegativeInteger")); + ma->setOffset( daeOffsetOf( domFx_stenciltarget_common , attrSlice )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_stenciltarget_common)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_surface_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_surface_common.cpp new file mode 100644 index 0000000..ae43bbc --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_surface_common.cpp @@ -0,0 +1,303 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_surface_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_surface_common::create(DAE& dae) +{ + domFx_surface_commonRef ref = new domFx_surface_common(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_surface_common" ); + meta->registerClass(domFx_surface_common::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "fx_surface_init_common" ); + mea->setOffset( daeOffsetOf(domFx_surface_common,elemFx_surface_init_common) ); + mea->setElementType( domFx_surface_init_common::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 0, 1 ) ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "format" ); + mea->setOffset( daeOffsetOf(domFx_surface_common,elemFormat) ); + mea->setElementType( domFx_surface_common::domFormat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "format_hint" ); + mea->setOffset( daeOffsetOf(domFx_surface_common,elemFormat_hint) ); + mea->setElementType( domFx_surface_format_hint_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 3, 0, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "size" ); + mea->setOffset( daeOffsetOf(domFx_surface_common,elemSize) ); + mea->setElementType( domFx_surface_common::domSize::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "viewport_ratio" ); + mea->setOffset( daeOffsetOf(domFx_surface_common,elemViewport_ratio) ); + mea->setElementType( domFx_surface_common::domViewport_ratio::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "mip_levels" ); + mea->setOffset( daeOffsetOf(domFx_surface_common,elemMip_levels) ); + mea->setElementType( domFx_surface_common::domMip_levels::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "mipmap_generate" ); + mea->setOffset( daeOffsetOf(domFx_surface_common,elemMipmap_generate) ); + mea->setElementType( domFx_surface_common::domMipmap_generate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 6, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domFx_surface_common,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 6 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domFx_surface_common,_contents)); + meta->addContentsOrder(daeOffsetOf(domFx_surface_common,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domFx_surface_common,_CMData), 1); + // Add attribute: type + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "type" ); + ma->setType( dae.getAtomicTypes().get("Fx_surface_type_enum")); + ma->setOffset( daeOffsetOf( domFx_surface_common , attrType )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_common::domFormat::create(DAE& dae) +{ + domFx_surface_common::domFormatRef ref = new domFx_surface_common::domFormat(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_common::domFormat::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "format" ); + meta->registerClass(domFx_surface_common::domFormat::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsToken")); + ma->setOffset( daeOffsetOf( domFx_surface_common::domFormat , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_common::domFormat)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_common::domSize::create(DAE& dae) +{ + domFx_surface_common::domSizeRef ref = new domFx_surface_common::domSize(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_common::domSize::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "size" ); + meta->registerClass(domFx_surface_common::domSize::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Int3")); + ma->setOffset( daeOffsetOf( domFx_surface_common::domSize , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_common::domSize)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_common::domViewport_ratio::create(DAE& dae) +{ + domFx_surface_common::domViewport_ratioRef ref = new domFx_surface_common::domViewport_ratio(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_common::domViewport_ratio::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "viewport_ratio" ); + meta->registerClass(domFx_surface_common::domViewport_ratio::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domFx_surface_common::domViewport_ratio , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_common::domViewport_ratio)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_common::domMip_levels::create(DAE& dae) +{ + domFx_surface_common::domMip_levelsRef ref = new domFx_surface_common::domMip_levels(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_common::domMip_levels::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mip_levels" ); + meta->registerClass(domFx_surface_common::domMip_levels::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedInt")); + ma->setOffset( daeOffsetOf( domFx_surface_common::domMip_levels , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_common::domMip_levels)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_common::domMipmap_generate::create(DAE& dae) +{ + domFx_surface_common::domMipmap_generateRef ref = new domFx_surface_common::domMipmap_generate(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_common::domMipmap_generate::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipmap_generate" ); + meta->registerClass(domFx_surface_common::domMipmap_generate::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsBoolean")); + ma->setOffset( daeOffsetOf( domFx_surface_common::domMipmap_generate , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_common::domMipmap_generate)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_surface_format_hint_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_surface_format_hint_common.cpp new file mode 100644 index 0000000..dd52576 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_surface_format_hint_common.cpp @@ -0,0 +1,227 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_surface_format_hint_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_surface_format_hint_common::create(DAE& dae) +{ + domFx_surface_format_hint_commonRef ref = new domFx_surface_format_hint_common(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_format_hint_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_surface_format_hint_common" ); + meta->registerClass(domFx_surface_format_hint_common::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "channels" ); + mea->setOffset( daeOffsetOf(domFx_surface_format_hint_common,elemChannels) ); + mea->setElementType( domFx_surface_format_hint_common::domChannels::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "range" ); + mea->setOffset( daeOffsetOf(domFx_surface_format_hint_common,elemRange) ); + mea->setElementType( domFx_surface_format_hint_common::domRange::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "precision" ); + mea->setOffset( daeOffsetOf(domFx_surface_format_hint_common,elemPrecision) ); + mea->setElementType( domFx_surface_format_hint_common::domPrecision::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "option" ); + mea->setOffset( daeOffsetOf(domFx_surface_format_hint_common,elemOption_array) ); + mea->setElementType( domFx_surface_format_hint_common::domOption::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 4, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domFx_surface_format_hint_common,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 4 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domFx_surface_format_hint_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_format_hint_common::domChannels::create(DAE& dae) +{ + domFx_surface_format_hint_common::domChannelsRef ref = new domFx_surface_format_hint_common::domChannels(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_format_hint_common::domChannels::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "channels" ); + meta->registerClass(domFx_surface_format_hint_common::domChannels::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_surface_format_hint_channels_enum")); + ma->setOffset( daeOffsetOf( domFx_surface_format_hint_common::domChannels , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_format_hint_common::domChannels)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_format_hint_common::domRange::create(DAE& dae) +{ + domFx_surface_format_hint_common::domRangeRef ref = new domFx_surface_format_hint_common::domRange(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_format_hint_common::domRange::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "range" ); + meta->registerClass(domFx_surface_format_hint_common::domRange::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_surface_format_hint_range_enum")); + ma->setOffset( daeOffsetOf( domFx_surface_format_hint_common::domRange , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_format_hint_common::domRange)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_format_hint_common::domPrecision::create(DAE& dae) +{ + domFx_surface_format_hint_common::domPrecisionRef ref = new domFx_surface_format_hint_common::domPrecision(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_format_hint_common::domPrecision::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "precision" ); + meta->registerClass(domFx_surface_format_hint_common::domPrecision::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_surface_format_hint_precision_enum")); + ma->setOffset( daeOffsetOf( domFx_surface_format_hint_common::domPrecision , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_format_hint_common::domPrecision)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_format_hint_common::domOption::create(DAE& dae) +{ + domFx_surface_format_hint_common::domOptionRef ref = new domFx_surface_format_hint_common::domOption(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_format_hint_common::domOption::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "option" ); + meta->registerClass(domFx_surface_format_hint_common::domOption::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_surface_format_hint_option_enum")); + ma->setOffset( daeOffsetOf( domFx_surface_format_hint_common::domOption , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_format_hint_common::domOption)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_surface_init_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_surface_init_common.cpp new file mode 100644 index 0000000..1928929 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_surface_init_common.cpp @@ -0,0 +1,148 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_surface_init_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_surface_init_common::create(DAE& dae) +{ + domFx_surface_init_commonRef ref = new domFx_surface_init_common(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_init_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_surface_init_common" ); + meta->registerClass(domFx_surface_init_common::create); + + meta->setIsTransparent( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "init_as_null" ); + mea->setOffset( daeOffsetOf(domFx_surface_init_common,elemInit_as_null) ); + mea->setElementType( domFx_surface_init_common::domInit_as_null::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "init_as_target" ); + mea->setOffset( daeOffsetOf(domFx_surface_init_common,elemInit_as_target) ); + mea->setElementType( domFx_surface_init_common::domInit_as_target::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "init_cube" ); + mea->setOffset( daeOffsetOf(domFx_surface_init_common,elemInit_cube) ); + mea->setElementType( domFx_surface_init_cube_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "init_volume" ); + mea->setOffset( daeOffsetOf(domFx_surface_init_common,elemInit_volume) ); + mea->setElementType( domFx_surface_init_volume_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "init_planar" ); + mea->setOffset( daeOffsetOf(domFx_surface_init_common,elemInit_planar) ); + mea->setElementType( domFx_surface_init_planar_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, -1 ); + mea->setName( "init_from" ); + mea->setOffset( daeOffsetOf(domFx_surface_init_common,elemInit_from_array) ); + mea->setElementType( domFx_surface_init_from_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domFx_surface_init_common,_contents)); + meta->addContentsOrder(daeOffsetOf(domFx_surface_init_common,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domFx_surface_init_common,_CMData), 1); + meta->setElementSize(sizeof(domFx_surface_init_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_init_common::domInit_as_null::create(DAE& dae) +{ + domFx_surface_init_common::domInit_as_nullRef ref = new domFx_surface_init_common::domInit_as_null(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_init_common::domInit_as_null::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "init_as_null" ); + meta->registerClass(domFx_surface_init_common::domInit_as_null::create); + + meta->setIsInnerClass( true ); + + meta->setElementSize(sizeof(domFx_surface_init_common::domInit_as_null)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_init_common::domInit_as_target::create(DAE& dae) +{ + domFx_surface_init_common::domInit_as_targetRef ref = new domFx_surface_init_common::domInit_as_target(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_init_common::domInit_as_target::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "init_as_target" ); + meta->registerClass(domFx_surface_init_common::domInit_as_target::create); + + meta->setIsInnerClass( true ); + + meta->setElementSize(sizeof(domFx_surface_init_common::domInit_as_target)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_surface_init_cube_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_surface_init_cube_common.cpp new file mode 100644 index 0000000..baf9d95 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_surface_init_cube_common.cpp @@ -0,0 +1,240 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_surface_init_cube_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_surface_init_cube_common::create(DAE& dae) +{ + domFx_surface_init_cube_commonRef ref = new domFx_surface_init_cube_common(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_init_cube_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_surface_init_cube_common" ); + meta->registerClass(domFx_surface_init_cube_common::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "all" ); + mea->setOffset( daeOffsetOf(domFx_surface_init_cube_common,elemAll) ); + mea->setElementType( domFx_surface_init_cube_common::domAll::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "primary" ); + mea->setOffset( daeOffsetOf(domFx_surface_init_cube_common,elemPrimary) ); + mea->setElementType( domFx_surface_init_cube_common::domPrimary::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 6, 6 ); + mea->setName( "face" ); + mea->setOffset( daeOffsetOf(domFx_surface_init_cube_common,elemFace_array) ); + mea->setElementType( domFx_surface_init_cube_common::domFace::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domFx_surface_init_cube_common,_contents)); + meta->addContentsOrder(daeOffsetOf(domFx_surface_init_cube_common,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domFx_surface_init_cube_common,_CMData), 1); + meta->setElementSize(sizeof(domFx_surface_init_cube_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_init_cube_common::domAll::create(DAE& dae) +{ + domFx_surface_init_cube_common::domAllRef ref = new domFx_surface_init_cube_common::domAll(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_init_cube_common::domAll::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "all" ); + meta->registerClass(domFx_surface_init_cube_common::domAll::create); + + meta->setIsInnerClass( true ); + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("xsIDREF")); + ma->setOffset( daeOffsetOf( domFx_surface_init_cube_common::domAll , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_init_cube_common::domAll)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_init_cube_common::domPrimary::create(DAE& dae) +{ + domFx_surface_init_cube_common::domPrimaryRef ref = new domFx_surface_init_cube_common::domPrimary(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_init_cube_common::domPrimary::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "primary" ); + meta->registerClass(domFx_surface_init_cube_common::domPrimary::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 0, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 6, 6 ); + mea->setName( "order" ); + mea->setOffset( daeOffsetOf(domFx_surface_init_cube_common::domPrimary,elemOrder_array) ); + mea->setElementType( domFx_surface_init_cube_common::domPrimary::domOrder::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("xsIDREF")); + ma->setOffset( daeOffsetOf( domFx_surface_init_cube_common::domPrimary , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_init_cube_common::domPrimary)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_init_cube_common::domPrimary::domOrder::create(DAE& dae) +{ + domFx_surface_init_cube_common::domPrimary::domOrderRef ref = new domFx_surface_init_cube_common::domPrimary::domOrder(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_init_cube_common::domPrimary::domOrder::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "order" ); + meta->registerClass(domFx_surface_init_cube_common::domPrimary::domOrder::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_surface_face_enum")); + ma->setOffset( daeOffsetOf( domFx_surface_init_cube_common::domPrimary::domOrder , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_init_cube_common::domPrimary::domOrder)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_init_cube_common::domFace::create(DAE& dae) +{ + domFx_surface_init_cube_common::domFaceRef ref = new domFx_surface_init_cube_common::domFace(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_init_cube_common::domFace::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "face" ); + meta->registerClass(domFx_surface_init_cube_common::domFace::create); + + meta->setIsInnerClass( true ); + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("xsIDREF")); + ma->setOffset( daeOffsetOf( domFx_surface_init_cube_common::domFace , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_init_cube_common::domFace)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_surface_init_from_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_surface_init_from_common.cpp new file mode 100644 index 0000000..11f44b2 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_surface_init_from_common.cpp @@ -0,0 +1,92 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_surface_init_from_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_surface_init_from_common::create(DAE& dae) +{ + domFx_surface_init_from_commonRef ref = new domFx_surface_init_from_common(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_init_from_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_surface_init_from_common" ); + meta->registerClass(domFx_surface_init_from_common::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsIDREF")); + ma->setOffset( daeOffsetOf( domFx_surface_init_from_common , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: mip + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "mip" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedInt")); + ma->setOffset( daeOffsetOf( domFx_surface_init_from_common , attrMip )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + + meta->appendAttribute(ma); + } + + // Add attribute: slice + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "slice" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedInt")); + ma->setOffset( daeOffsetOf( domFx_surface_init_from_common , attrSlice )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + + meta->appendAttribute(ma); + } + + // Add attribute: face + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "face" ); + ma->setType( dae.getAtomicTypes().get("Fx_surface_face_enum")); + ma->setOffset( daeOffsetOf( domFx_surface_init_from_common , attrFace )); + ma->setContainer( meta ); + ma->setDefaultString( "POSITIVE_X"); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_init_from_common)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_surface_init_planar_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_surface_init_planar_common.cpp new file mode 100644 index 0000000..78339b1 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_surface_init_planar_common.cpp @@ -0,0 +1,102 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_surface_init_planar_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_surface_init_planar_common::create(DAE& dae) +{ + domFx_surface_init_planar_commonRef ref = new domFx_surface_init_planar_common(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_init_planar_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_surface_init_planar_common" ); + meta->registerClass(domFx_surface_init_planar_common::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "all" ); + mea->setOffset( daeOffsetOf(domFx_surface_init_planar_common,elemAll) ); + mea->setElementType( domFx_surface_init_planar_common::domAll::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domFx_surface_init_planar_common,_contents)); + meta->addContentsOrder(daeOffsetOf(domFx_surface_init_planar_common,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domFx_surface_init_planar_common,_CMData), 1); + meta->setElementSize(sizeof(domFx_surface_init_planar_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_init_planar_common::domAll::create(DAE& dae) +{ + domFx_surface_init_planar_common::domAllRef ref = new domFx_surface_init_planar_common::domAll(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_init_planar_common::domAll::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "all" ); + meta->registerClass(domFx_surface_init_planar_common::domAll::create); + + meta->setIsInnerClass( true ); + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("xsIDREF")); + ma->setOffset( daeOffsetOf( domFx_surface_init_planar_common::domAll , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_init_planar_common::domAll)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domFx_surface_init_volume_common.cpp b/1.4.0/dom/src/1.4/dom/domFx_surface_init_volume_common.cpp new file mode 100644 index 0000000..5fbf8f9 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domFx_surface_init_volume_common.cpp @@ -0,0 +1,147 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domFx_surface_init_volume_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domFx_surface_init_volume_common::create(DAE& dae) +{ + domFx_surface_init_volume_commonRef ref = new domFx_surface_init_volume_common(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_init_volume_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fx_surface_init_volume_common" ); + meta->registerClass(domFx_surface_init_volume_common::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "all" ); + mea->setOffset( daeOffsetOf(domFx_surface_init_volume_common,elemAll) ); + mea->setElementType( domFx_surface_init_volume_common::domAll::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "primary" ); + mea->setOffset( daeOffsetOf(domFx_surface_init_volume_common,elemPrimary) ); + mea->setElementType( domFx_surface_init_volume_common::domPrimary::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domFx_surface_init_volume_common,_contents)); + meta->addContentsOrder(daeOffsetOf(domFx_surface_init_volume_common,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domFx_surface_init_volume_common,_CMData), 1); + meta->setElementSize(sizeof(domFx_surface_init_volume_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_init_volume_common::domAll::create(DAE& dae) +{ + domFx_surface_init_volume_common::domAllRef ref = new domFx_surface_init_volume_common::domAll(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_init_volume_common::domAll::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "all" ); + meta->registerClass(domFx_surface_init_volume_common::domAll::create); + + meta->setIsInnerClass( true ); + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("xsIDREF")); + ma->setOffset( daeOffsetOf( domFx_surface_init_volume_common::domAll , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_init_volume_common::domAll)); + meta->validate(); + + return meta; +} + +daeElementRef +domFx_surface_init_volume_common::domPrimary::create(DAE& dae) +{ + domFx_surface_init_volume_common::domPrimaryRef ref = new domFx_surface_init_volume_common::domPrimary(dae); + return ref; +} + + +daeMetaElement * +domFx_surface_init_volume_common::domPrimary::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "primary" ); + meta->registerClass(domFx_surface_init_volume_common::domPrimary::create); + + meta->setIsInnerClass( true ); + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("xsIDREF")); + ma->setOffset( daeOffsetOf( domFx_surface_init_volume_common::domPrimary , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domFx_surface_init_volume_common::domPrimary)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGeometry.cpp b/1.4.0/dom/src/1.4/dom/domGeometry.cpp new file mode 100644 index 0000000..85f02f9 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGeometry.cpp @@ -0,0 +1,115 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGeometry.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGeometry::create(DAE& dae) +{ + domGeometryRef ref = new domGeometry(dae); + return ref; +} + + +daeMetaElement * +domGeometry::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "geometry" ); + meta->registerClass(domGeometry::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domGeometry,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "convex_mesh" ); + mea->setOffset( daeOffsetOf(domGeometry,elemConvex_mesh) ); + mea->setElementType( domConvex_mesh::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "mesh" ); + mea->setOffset( daeOffsetOf(domGeometry,elemMesh) ); + mea->setElementType( domMesh::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "spline" ); + mea->setOffset( daeOffsetOf(domGeometry,elemSpline) ); + mea->setElementType( domSpline::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domGeometry,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGeometry,_contents)); + meta->addContentsOrder(daeOffsetOf(domGeometry,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGeometry,_CMData), 1); + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domGeometry , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGeometry , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGeometry)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGl_hook_abstract.cpp b/1.4.0/dom/src/1.4/dom/domGl_hook_abstract.cpp new file mode 100644 index 0000000..aae95e4 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGl_hook_abstract.cpp @@ -0,0 +1,48 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGl_hook_abstract.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGl_hook_abstract::create(DAE& dae) +{ + domGl_hook_abstractRef ref = new domGl_hook_abstract(dae); + return ref; +} + + +daeMetaElement * +domGl_hook_abstract::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gl_hook_abstract" ); + meta->registerClass(domGl_hook_abstract::create); + + meta->setIsAbstract( true ); + + meta->setElementSize(sizeof(domGl_hook_abstract)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGl_pipeline_settings.cpp b/1.4.0/dom/src/1.4/dom/domGl_pipeline_settings.cpp new file mode 100644 index 0000000..dbbf7c5 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGl_pipeline_settings.cpp @@ -0,0 +1,8367 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGl_pipeline_settings.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGl_pipeline_settings::create(DAE& dae) +{ + domGl_pipeline_settingsRef ref = new domGl_pipeline_settings(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gl_pipeline_settings" ); + meta->registerClass(domGl_pipeline_settings::create); + + meta->setIsTransparent( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "alpha_func" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemAlpha_func) ); + mea->setElementType( domGl_pipeline_settings::domAlpha_func::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "blend_func" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemBlend_func) ); + mea->setElementType( domGl_pipeline_settings::domBlend_func::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "blend_func_separate" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemBlend_func_separate) ); + mea->setElementType( domGl_pipeline_settings::domBlend_func_separate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "blend_equation" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemBlend_equation) ); + mea->setElementType( domGl_pipeline_settings::domBlend_equation::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "blend_equation_separate" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemBlend_equation_separate) ); + mea->setElementType( domGl_pipeline_settings::domBlend_equation_separate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "color_material" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemColor_material) ); + mea->setElementType( domGl_pipeline_settings::domColor_material::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "cull_face" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemCull_face) ); + mea->setElementType( domGl_pipeline_settings::domCull_face::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "depth_func" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemDepth_func) ); + mea->setElementType( domGl_pipeline_settings::domDepth_func::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fog_mode" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemFog_mode) ); + mea->setElementType( domGl_pipeline_settings::domFog_mode::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fog_coord_src" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemFog_coord_src) ); + mea->setElementType( domGl_pipeline_settings::domFog_coord_src::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "front_face" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemFront_face) ); + mea->setElementType( domGl_pipeline_settings::domFront_face::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_model_color_control" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLight_model_color_control) ); + mea->setElementType( domGl_pipeline_settings::domLight_model_color_control::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "logic_op" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLogic_op) ); + mea->setElementType( domGl_pipeline_settings::domLogic_op::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "polygon_mode" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemPolygon_mode) ); + mea->setElementType( domGl_pipeline_settings::domPolygon_mode::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "shade_model" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemShade_model) ); + mea->setElementType( domGl_pipeline_settings::domShade_model::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "stencil_func" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemStencil_func) ); + mea->setElementType( domGl_pipeline_settings::domStencil_func::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "stencil_op" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemStencil_op) ); + mea->setElementType( domGl_pipeline_settings::domStencil_op::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "stencil_func_separate" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemStencil_func_separate) ); + mea->setElementType( domGl_pipeline_settings::domStencil_func_separate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "stencil_op_separate" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemStencil_op_separate) ); + mea->setElementType( domGl_pipeline_settings::domStencil_op_separate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "stencil_mask_separate" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemStencil_mask_separate) ); + mea->setElementType( domGl_pipeline_settings::domStencil_mask_separate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLight_enable) ); + mea->setElementType( domGl_pipeline_settings::domLight_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_ambient" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLight_ambient) ); + mea->setElementType( domGl_pipeline_settings::domLight_ambient::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_diffuse" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLight_diffuse) ); + mea->setElementType( domGl_pipeline_settings::domLight_diffuse::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_specular" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLight_specular) ); + mea->setElementType( domGl_pipeline_settings::domLight_specular::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_position" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLight_position) ); + mea->setElementType( domGl_pipeline_settings::domLight_position::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_constant_attenuation" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLight_constant_attenuation) ); + mea->setElementType( domGl_pipeline_settings::domLight_constant_attenuation::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_linear_attenuation" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLight_linear_attenuation) ); + mea->setElementType( domGl_pipeline_settings::domLight_linear_attenuation::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_quadratic_attenuation" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLight_quadratic_attenuation) ); + mea->setElementType( domGl_pipeline_settings::domLight_quadratic_attenuation::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_spot_cutoff" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLight_spot_cutoff) ); + mea->setElementType( domGl_pipeline_settings::domLight_spot_cutoff::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_spot_direction" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLight_spot_direction) ); + mea->setElementType( domGl_pipeline_settings::domLight_spot_direction::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_spot_exponent" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLight_spot_exponent) ); + mea->setElementType( domGl_pipeline_settings::domLight_spot_exponent::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texture1D" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemTexture1D) ); + mea->setElementType( domGl_pipeline_settings::domTexture1D::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texture2D" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemTexture2D) ); + mea->setElementType( domGl_pipeline_settings::domTexture2D::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texture3D" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemTexture3D) ); + mea->setElementType( domGl_pipeline_settings::domTexture3D::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "textureCUBE" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemTextureCUBE) ); + mea->setElementType( domGl_pipeline_settings::domTextureCUBE::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "textureRECT" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemTextureRECT) ); + mea->setElementType( domGl_pipeline_settings::domTextureRECT::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "textureDEPTH" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemTextureDEPTH) ); + mea->setElementType( domGl_pipeline_settings::domTextureDEPTH::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texture1D_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemTexture1D_enable) ); + mea->setElementType( domGl_pipeline_settings::domTexture1D_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texture2D_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemTexture2D_enable) ); + mea->setElementType( domGl_pipeline_settings::domTexture2D_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texture3D_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemTexture3D_enable) ); + mea->setElementType( domGl_pipeline_settings::domTexture3D_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "textureCUBE_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemTextureCUBE_enable) ); + mea->setElementType( domGl_pipeline_settings::domTextureCUBE_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "textureRECT_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemTextureRECT_enable) ); + mea->setElementType( domGl_pipeline_settings::domTextureRECT_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "textureDEPTH_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemTextureDEPTH_enable) ); + mea->setElementType( domGl_pipeline_settings::domTextureDEPTH_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texture_env_color" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemTexture_env_color) ); + mea->setElementType( domGl_pipeline_settings::domTexture_env_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texture_env_mode" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemTexture_env_mode) ); + mea->setElementType( domGl_pipeline_settings::domTexture_env_mode::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "clip_plane" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemClip_plane) ); + mea->setElementType( domGl_pipeline_settings::domClip_plane::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "clip_plane_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemClip_plane_enable) ); + mea->setElementType( domGl_pipeline_settings::domClip_plane_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "blend_color" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemBlend_color) ); + mea->setElementType( domGl_pipeline_settings::domBlend_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "clear_color" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemClear_color) ); + mea->setElementType( domGl_pipeline_settings::domClear_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "clear_stencil" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemClear_stencil) ); + mea->setElementType( domGl_pipeline_settings::domClear_stencil::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "clear_depth" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemClear_depth) ); + mea->setElementType( domGl_pipeline_settings::domClear_depth::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "color_mask" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemColor_mask) ); + mea->setElementType( domGl_pipeline_settings::domColor_mask::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "depth_bounds" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemDepth_bounds) ); + mea->setElementType( domGl_pipeline_settings::domDepth_bounds::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "depth_mask" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemDepth_mask) ); + mea->setElementType( domGl_pipeline_settings::domDepth_mask::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "depth_range" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemDepth_range) ); + mea->setElementType( domGl_pipeline_settings::domDepth_range::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fog_density" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemFog_density) ); + mea->setElementType( domGl_pipeline_settings::domFog_density::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fog_start" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemFog_start) ); + mea->setElementType( domGl_pipeline_settings::domFog_start::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fog_end" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemFog_end) ); + mea->setElementType( domGl_pipeline_settings::domFog_end::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fog_color" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemFog_color) ); + mea->setElementType( domGl_pipeline_settings::domFog_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_model_ambient" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLight_model_ambient) ); + mea->setElementType( domGl_pipeline_settings::domLight_model_ambient::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "lighting_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLighting_enable) ); + mea->setElementType( domGl_pipeline_settings::domLighting_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "line_stipple" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLine_stipple) ); + mea->setElementType( domGl_pipeline_settings::domLine_stipple::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "line_width" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLine_width) ); + mea->setElementType( domGl_pipeline_settings::domLine_width::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "material_ambient" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemMaterial_ambient) ); + mea->setElementType( domGl_pipeline_settings::domMaterial_ambient::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "material_diffuse" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemMaterial_diffuse) ); + mea->setElementType( domGl_pipeline_settings::domMaterial_diffuse::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "material_emission" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemMaterial_emission) ); + mea->setElementType( domGl_pipeline_settings::domMaterial_emission::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "material_shininess" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemMaterial_shininess) ); + mea->setElementType( domGl_pipeline_settings::domMaterial_shininess::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "material_specular" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemMaterial_specular) ); + mea->setElementType( domGl_pipeline_settings::domMaterial_specular::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "model_view_matrix" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemModel_view_matrix) ); + mea->setElementType( domGl_pipeline_settings::domModel_view_matrix::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "point_distance_attenuation" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemPoint_distance_attenuation) ); + mea->setElementType( domGl_pipeline_settings::domPoint_distance_attenuation::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "point_fade_threshold_size" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemPoint_fade_threshold_size) ); + mea->setElementType( domGl_pipeline_settings::domPoint_fade_threshold_size::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "point_size" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemPoint_size) ); + mea->setElementType( domGl_pipeline_settings::domPoint_size::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "point_size_min" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemPoint_size_min) ); + mea->setElementType( domGl_pipeline_settings::domPoint_size_min::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "point_size_max" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemPoint_size_max) ); + mea->setElementType( domGl_pipeline_settings::domPoint_size_max::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "polygon_offset" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemPolygon_offset) ); + mea->setElementType( domGl_pipeline_settings::domPolygon_offset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "projection_matrix" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemProjection_matrix) ); + mea->setElementType( domGl_pipeline_settings::domProjection_matrix::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "scissor" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemScissor) ); + mea->setElementType( domGl_pipeline_settings::domScissor::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "stencil_mask" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemStencil_mask) ); + mea->setElementType( domGl_pipeline_settings::domStencil_mask::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "alpha_test_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemAlpha_test_enable) ); + mea->setElementType( domGl_pipeline_settings::domAlpha_test_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "auto_normal_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemAuto_normal_enable) ); + mea->setElementType( domGl_pipeline_settings::domAuto_normal_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "blend_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemBlend_enable) ); + mea->setElementType( domGl_pipeline_settings::domBlend_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "color_logic_op_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemColor_logic_op_enable) ); + mea->setElementType( domGl_pipeline_settings::domColor_logic_op_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "color_material_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemColor_material_enable) ); + mea->setElementType( domGl_pipeline_settings::domColor_material_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "cull_face_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemCull_face_enable) ); + mea->setElementType( domGl_pipeline_settings::domCull_face_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "depth_bounds_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemDepth_bounds_enable) ); + mea->setElementType( domGl_pipeline_settings::domDepth_bounds_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "depth_clamp_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemDepth_clamp_enable) ); + mea->setElementType( domGl_pipeline_settings::domDepth_clamp_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "depth_test_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemDepth_test_enable) ); + mea->setElementType( domGl_pipeline_settings::domDepth_test_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "dither_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemDither_enable) ); + mea->setElementType( domGl_pipeline_settings::domDither_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fog_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemFog_enable) ); + mea->setElementType( domGl_pipeline_settings::domFog_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_model_local_viewer_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLight_model_local_viewer_enable) ); + mea->setElementType( domGl_pipeline_settings::domLight_model_local_viewer_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_model_two_side_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLight_model_two_side_enable) ); + mea->setElementType( domGl_pipeline_settings::domLight_model_two_side_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "line_smooth_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLine_smooth_enable) ); + mea->setElementType( domGl_pipeline_settings::domLine_smooth_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "line_stipple_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLine_stipple_enable) ); + mea->setElementType( domGl_pipeline_settings::domLine_stipple_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "logic_op_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemLogic_op_enable) ); + mea->setElementType( domGl_pipeline_settings::domLogic_op_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "multisample_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemMultisample_enable) ); + mea->setElementType( domGl_pipeline_settings::domMultisample_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "normalize_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemNormalize_enable) ); + mea->setElementType( domGl_pipeline_settings::domNormalize_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "point_smooth_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemPoint_smooth_enable) ); + mea->setElementType( domGl_pipeline_settings::domPoint_smooth_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "polygon_offset_fill_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemPolygon_offset_fill_enable) ); + mea->setElementType( domGl_pipeline_settings::domPolygon_offset_fill_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "polygon_offset_line_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemPolygon_offset_line_enable) ); + mea->setElementType( domGl_pipeline_settings::domPolygon_offset_line_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "polygon_offset_point_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemPolygon_offset_point_enable) ); + mea->setElementType( domGl_pipeline_settings::domPolygon_offset_point_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "polygon_smooth_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemPolygon_smooth_enable) ); + mea->setElementType( domGl_pipeline_settings::domPolygon_smooth_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "polygon_stipple_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemPolygon_stipple_enable) ); + mea->setElementType( domGl_pipeline_settings::domPolygon_stipple_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "rescale_normal_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemRescale_normal_enable) ); + mea->setElementType( domGl_pipeline_settings::domRescale_normal_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sample_alpha_to_coverage_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemSample_alpha_to_coverage_enable) ); + mea->setElementType( domGl_pipeline_settings::domSample_alpha_to_coverage_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sample_alpha_to_one_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemSample_alpha_to_one_enable) ); + mea->setElementType( domGl_pipeline_settings::domSample_alpha_to_one_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sample_coverage_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemSample_coverage_enable) ); + mea->setElementType( domGl_pipeline_settings::domSample_coverage_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "scissor_test_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemScissor_test_enable) ); + mea->setElementType( domGl_pipeline_settings::domScissor_test_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "stencil_test_enable" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemStencil_test_enable) ); + mea->setElementType( domGl_pipeline_settings::domStencil_test_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "gl_hook_abstract" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings,elemGl_hook_abstract) ); + mea->setElementType( domGl_hook_abstract::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGl_pipeline_settings,_contents)); + meta->addContentsOrder(daeOffsetOf(domGl_pipeline_settings,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGl_pipeline_settings,_CMData), 1); + meta->setElementSize(sizeof(domGl_pipeline_settings)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domAlpha_func::create(DAE& dae) +{ + domGl_pipeline_settings::domAlpha_funcRef ref = new domGl_pipeline_settings::domAlpha_func(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domAlpha_func::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "alpha_func" ); + meta->registerClass(domGl_pipeline_settings::domAlpha_func::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "func" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domAlpha_func,elemFunc) ); + mea->setElementType( domGl_pipeline_settings::domAlpha_func::domFunc::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "value" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domAlpha_func,elemValue) ); + mea->setElementType( domGl_pipeline_settings::domAlpha_func::domValue::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_pipeline_settings::domAlpha_func)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domAlpha_func::domFunc::create(DAE& dae) +{ + domGl_pipeline_settings::domAlpha_func::domFuncRef ref = new domGl_pipeline_settings::domAlpha_func::domFunc(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domAlpha_func::domFunc::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "func" ); + meta->registerClass(domGl_pipeline_settings::domAlpha_func::domFunc::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_func_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domAlpha_func::domFunc , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ALWAYS"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domAlpha_func::domFunc , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domAlpha_func::domFunc)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domAlpha_func::domValue::create(DAE& dae) +{ + domGl_pipeline_settings::domAlpha_func::domValueRef ref = new domGl_pipeline_settings::domAlpha_func::domValue(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domAlpha_func::domValue::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "value" ); + meta->registerClass(domGl_pipeline_settings::domAlpha_func::domValue::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_alpha_value_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domAlpha_func::domValue , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0.0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domAlpha_func::domValue , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domAlpha_func::domValue)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domBlend_func::create(DAE& dae) +{ + domGl_pipeline_settings::domBlend_funcRef ref = new domGl_pipeline_settings::domBlend_func(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domBlend_func::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "blend_func" ); + meta->registerClass(domGl_pipeline_settings::domBlend_func::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "src" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domBlend_func,elemSrc) ); + mea->setElementType( domGl_pipeline_settings::domBlend_func::domSrc::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "dest" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domBlend_func,elemDest) ); + mea->setElementType( domGl_pipeline_settings::domBlend_func::domDest::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_pipeline_settings::domBlend_func)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domBlend_func::domSrc::create(DAE& dae) +{ + domGl_pipeline_settings::domBlend_func::domSrcRef ref = new domGl_pipeline_settings::domBlend_func::domSrc(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domBlend_func::domSrc::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "src" ); + meta->registerClass(domGl_pipeline_settings::domBlend_func::domSrc::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_blend_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_func::domSrc , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ONE"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_func::domSrc , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domBlend_func::domSrc)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domBlend_func::domDest::create(DAE& dae) +{ + domGl_pipeline_settings::domBlend_func::domDestRef ref = new domGl_pipeline_settings::domBlend_func::domDest(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domBlend_func::domDest::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "dest" ); + meta->registerClass(domGl_pipeline_settings::domBlend_func::domDest::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_blend_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_func::domDest , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ZERO"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_func::domDest , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domBlend_func::domDest)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domBlend_func_separate::create(DAE& dae) +{ + domGl_pipeline_settings::domBlend_func_separateRef ref = new domGl_pipeline_settings::domBlend_func_separate(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domBlend_func_separate::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "blend_func_separate" ); + meta->registerClass(domGl_pipeline_settings::domBlend_func_separate::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "src_rgb" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domBlend_func_separate,elemSrc_rgb) ); + mea->setElementType( domGl_pipeline_settings::domBlend_func_separate::domSrc_rgb::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "dest_rgb" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domBlend_func_separate,elemDest_rgb) ); + mea->setElementType( domGl_pipeline_settings::domBlend_func_separate::domDest_rgb::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 1, 1 ); + mea->setName( "src_alpha" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domBlend_func_separate,elemSrc_alpha) ); + mea->setElementType( domGl_pipeline_settings::domBlend_func_separate::domSrc_alpha::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 1, 1 ); + mea->setName( "dest_alpha" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domBlend_func_separate,elemDest_alpha) ); + mea->setElementType( domGl_pipeline_settings::domBlend_func_separate::domDest_alpha::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_pipeline_settings::domBlend_func_separate)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domBlend_func_separate::domSrc_rgb::create(DAE& dae) +{ + domGl_pipeline_settings::domBlend_func_separate::domSrc_rgbRef ref = new domGl_pipeline_settings::domBlend_func_separate::domSrc_rgb(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domBlend_func_separate::domSrc_rgb::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "src_rgb" ); + meta->registerClass(domGl_pipeline_settings::domBlend_func_separate::domSrc_rgb::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_blend_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_func_separate::domSrc_rgb , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ONE"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_func_separate::domSrc_rgb , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domBlend_func_separate::domSrc_rgb)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domBlend_func_separate::domDest_rgb::create(DAE& dae) +{ + domGl_pipeline_settings::domBlend_func_separate::domDest_rgbRef ref = new domGl_pipeline_settings::domBlend_func_separate::domDest_rgb(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domBlend_func_separate::domDest_rgb::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "dest_rgb" ); + meta->registerClass(domGl_pipeline_settings::domBlend_func_separate::domDest_rgb::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_blend_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_func_separate::domDest_rgb , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ZERO"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_func_separate::domDest_rgb , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domBlend_func_separate::domDest_rgb)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domBlend_func_separate::domSrc_alpha::create(DAE& dae) +{ + domGl_pipeline_settings::domBlend_func_separate::domSrc_alphaRef ref = new domGl_pipeline_settings::domBlend_func_separate::domSrc_alpha(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domBlend_func_separate::domSrc_alpha::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "src_alpha" ); + meta->registerClass(domGl_pipeline_settings::domBlend_func_separate::domSrc_alpha::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_blend_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_func_separate::domSrc_alpha , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ONE"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_func_separate::domSrc_alpha , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domBlend_func_separate::domSrc_alpha)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domBlend_func_separate::domDest_alpha::create(DAE& dae) +{ + domGl_pipeline_settings::domBlend_func_separate::domDest_alphaRef ref = new domGl_pipeline_settings::domBlend_func_separate::domDest_alpha(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domBlend_func_separate::domDest_alpha::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "dest_alpha" ); + meta->registerClass(domGl_pipeline_settings::domBlend_func_separate::domDest_alpha::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_blend_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_func_separate::domDest_alpha , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ZERO"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_func_separate::domDest_alpha , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domBlend_func_separate::domDest_alpha)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domBlend_equation::create(DAE& dae) +{ + domGl_pipeline_settings::domBlend_equationRef ref = new domGl_pipeline_settings::domBlend_equation(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domBlend_equation::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "blend_equation" ); + meta->registerClass(domGl_pipeline_settings::domBlend_equation::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_blend_equation_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_equation , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "FUNC_ADD"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_equation , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domBlend_equation)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domBlend_equation_separate::create(DAE& dae) +{ + domGl_pipeline_settings::domBlend_equation_separateRef ref = new domGl_pipeline_settings::domBlend_equation_separate(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domBlend_equation_separate::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "blend_equation_separate" ); + meta->registerClass(domGl_pipeline_settings::domBlend_equation_separate::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "rgb" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domBlend_equation_separate,elemRgb) ); + mea->setElementType( domGl_pipeline_settings::domBlend_equation_separate::domRgb::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "alpha" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domBlend_equation_separate,elemAlpha) ); + mea->setElementType( domGl_pipeline_settings::domBlend_equation_separate::domAlpha::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_pipeline_settings::domBlend_equation_separate)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domBlend_equation_separate::domRgb::create(DAE& dae) +{ + domGl_pipeline_settings::domBlend_equation_separate::domRgbRef ref = new domGl_pipeline_settings::domBlend_equation_separate::domRgb(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domBlend_equation_separate::domRgb::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "rgb" ); + meta->registerClass(domGl_pipeline_settings::domBlend_equation_separate::domRgb::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_blend_equation_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_equation_separate::domRgb , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "FUNC_ADD"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_equation_separate::domRgb , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domBlend_equation_separate::domRgb)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domBlend_equation_separate::domAlpha::create(DAE& dae) +{ + domGl_pipeline_settings::domBlend_equation_separate::domAlphaRef ref = new domGl_pipeline_settings::domBlend_equation_separate::domAlpha(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domBlend_equation_separate::domAlpha::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "alpha" ); + meta->registerClass(domGl_pipeline_settings::domBlend_equation_separate::domAlpha::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_blend_equation_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_equation_separate::domAlpha , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "FUNC_ADD"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_equation_separate::domAlpha , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domBlend_equation_separate::domAlpha)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domColor_material::create(DAE& dae) +{ + domGl_pipeline_settings::domColor_materialRef ref = new domGl_pipeline_settings::domColor_material(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domColor_material::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "color_material" ); + meta->registerClass(domGl_pipeline_settings::domColor_material::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "face" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domColor_material,elemFace) ); + mea->setElementType( domGl_pipeline_settings::domColor_material::domFace::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "mode" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domColor_material,elemMode) ); + mea->setElementType( domGl_pipeline_settings::domColor_material::domMode::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_pipeline_settings::domColor_material)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domColor_material::domFace::create(DAE& dae) +{ + domGl_pipeline_settings::domColor_material::domFaceRef ref = new domGl_pipeline_settings::domColor_material::domFace(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domColor_material::domFace::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "face" ); + meta->registerClass(domGl_pipeline_settings::domColor_material::domFace::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_face_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domColor_material::domFace , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "FRONT_AND_BACK"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domColor_material::domFace , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domColor_material::domFace)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domColor_material::domMode::create(DAE& dae) +{ + domGl_pipeline_settings::domColor_material::domModeRef ref = new domGl_pipeline_settings::domColor_material::domMode(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domColor_material::domMode::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mode" ); + meta->registerClass(domGl_pipeline_settings::domColor_material::domMode::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_material_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domColor_material::domMode , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "AMBIENT_AND_DIFFUSE"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domColor_material::domMode , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domColor_material::domMode)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domCull_face::create(DAE& dae) +{ + domGl_pipeline_settings::domCull_faceRef ref = new domGl_pipeline_settings::domCull_face(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domCull_face::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cull_face" ); + meta->registerClass(domGl_pipeline_settings::domCull_face::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_face_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domCull_face , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "BACK"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domCull_face , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domCull_face)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domDepth_func::create(DAE& dae) +{ + domGl_pipeline_settings::domDepth_funcRef ref = new domGl_pipeline_settings::domDepth_func(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domDepth_func::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "depth_func" ); + meta->registerClass(domGl_pipeline_settings::domDepth_func::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_func_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDepth_func , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ALWAYS"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDepth_func , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domDepth_func)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domFog_mode::create(DAE& dae) +{ + domGl_pipeline_settings::domFog_modeRef ref = new domGl_pipeline_settings::domFog_mode(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domFog_mode::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fog_mode" ); + meta->registerClass(domGl_pipeline_settings::domFog_mode::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_fog_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFog_mode , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "EXP"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFog_mode , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domFog_mode)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domFog_coord_src::create(DAE& dae) +{ + domGl_pipeline_settings::domFog_coord_srcRef ref = new domGl_pipeline_settings::domFog_coord_src(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domFog_coord_src::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fog_coord_src" ); + meta->registerClass(domGl_pipeline_settings::domFog_coord_src::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_fog_coord_src_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFog_coord_src , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "FOG_COORDINATE"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFog_coord_src , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domFog_coord_src)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domFront_face::create(DAE& dae) +{ + domGl_pipeline_settings::domFront_faceRef ref = new domGl_pipeline_settings::domFront_face(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domFront_face::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "front_face" ); + meta->registerClass(domGl_pipeline_settings::domFront_face::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_front_face_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFront_face , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "CCW"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFront_face , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domFront_face)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLight_model_color_control::create(DAE& dae) +{ + domGl_pipeline_settings::domLight_model_color_controlRef ref = new domGl_pipeline_settings::domLight_model_color_control(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLight_model_color_control::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_model_color_control" ); + meta->registerClass(domGl_pipeline_settings::domLight_model_color_control::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_light_model_color_control_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_model_color_control , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "SINGLE_COLOR"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_model_color_control , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLight_model_color_control)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLogic_op::create(DAE& dae) +{ + domGl_pipeline_settings::domLogic_opRef ref = new domGl_pipeline_settings::domLogic_op(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLogic_op::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "logic_op" ); + meta->registerClass(domGl_pipeline_settings::domLogic_op::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_logic_op_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLogic_op , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "COPY"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLogic_op , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLogic_op)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domPolygon_mode::create(DAE& dae) +{ + domGl_pipeline_settings::domPolygon_modeRef ref = new domGl_pipeline_settings::domPolygon_mode(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domPolygon_mode::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "polygon_mode" ); + meta->registerClass(domGl_pipeline_settings::domPolygon_mode::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "face" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domPolygon_mode,elemFace) ); + mea->setElementType( domGl_pipeline_settings::domPolygon_mode::domFace::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "mode" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domPolygon_mode,elemMode) ); + mea->setElementType( domGl_pipeline_settings::domPolygon_mode::domMode::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_pipeline_settings::domPolygon_mode)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domPolygon_mode::domFace::create(DAE& dae) +{ + domGl_pipeline_settings::domPolygon_mode::domFaceRef ref = new domGl_pipeline_settings::domPolygon_mode::domFace(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domPolygon_mode::domFace::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "face" ); + meta->registerClass(domGl_pipeline_settings::domPolygon_mode::domFace::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_face_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_mode::domFace , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "FRONT_AND_BACK"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_mode::domFace , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domPolygon_mode::domFace)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domPolygon_mode::domMode::create(DAE& dae) +{ + domGl_pipeline_settings::domPolygon_mode::domModeRef ref = new domGl_pipeline_settings::domPolygon_mode::domMode(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domPolygon_mode::domMode::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mode" ); + meta->registerClass(domGl_pipeline_settings::domPolygon_mode::domMode::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_polygon_mode_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_mode::domMode , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "FILL"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_mode::domMode , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domPolygon_mode::domMode)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domShade_model::create(DAE& dae) +{ + domGl_pipeline_settings::domShade_modelRef ref = new domGl_pipeline_settings::domShade_model(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domShade_model::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "shade_model" ); + meta->registerClass(domGl_pipeline_settings::domShade_model::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_shade_model_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domShade_model , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "SMOOTH"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domShade_model , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domShade_model)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_func::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_funcRef ref = new domGl_pipeline_settings::domStencil_func(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_func::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "stencil_func" ); + meta->registerClass(domGl_pipeline_settings::domStencil_func::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "func" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_func,elemFunc) ); + mea->setElementType( domGl_pipeline_settings::domStencil_func::domFunc::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "ref" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_func,elemRef) ); + mea->setElementType( domGl_pipeline_settings::domStencil_func::domRef::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 1, 1 ); + mea->setName( "mask" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_func,elemMask) ); + mea->setElementType( domGl_pipeline_settings::domStencil_func::domMask::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_func)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_func::domFunc::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_func::domFuncRef ref = new domGl_pipeline_settings::domStencil_func::domFunc(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_func::domFunc::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "func" ); + meta->registerClass(domGl_pipeline_settings::domStencil_func::domFunc::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_func_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_func::domFunc , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ALWAYS"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_func::domFunc , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_func::domFunc)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_func::domRef::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_func::domRefRef ref = new domGl_pipeline_settings::domStencil_func::domRef(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_func::domRef::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "ref" ); + meta->registerClass(domGl_pipeline_settings::domStencil_func::domRef::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedByte")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_func::domRef , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_func::domRef , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_func::domRef)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_func::domMask::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_func::domMaskRef ref = new domGl_pipeline_settings::domStencil_func::domMask(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_func::domMask::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mask" ); + meta->registerClass(domGl_pipeline_settings::domStencil_func::domMask::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedByte")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_func::domMask , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "255"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_func::domMask , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_func::domMask)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_op::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_opRef ref = new domGl_pipeline_settings::domStencil_op(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_op::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "stencil_op" ); + meta->registerClass(domGl_pipeline_settings::domStencil_op::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fail" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_op,elemFail) ); + mea->setElementType( domGl_pipeline_settings::domStencil_op::domFail::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "zfail" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_op,elemZfail) ); + mea->setElementType( domGl_pipeline_settings::domStencil_op::domZfail::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 1, 1 ); + mea->setName( "zpass" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_op,elemZpass) ); + mea->setElementType( domGl_pipeline_settings::domStencil_op::domZpass::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_op)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_op::domFail::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_op::domFailRef ref = new domGl_pipeline_settings::domStencil_op::domFail(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_op::domFail::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fail" ); + meta->registerClass(domGl_pipeline_settings::domStencil_op::domFail::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_stencil_op_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_op::domFail , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "KEEP"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_op::domFail , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_op::domFail)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_op::domZfail::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_op::domZfailRef ref = new domGl_pipeline_settings::domStencil_op::domZfail(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_op::domZfail::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "zfail" ); + meta->registerClass(domGl_pipeline_settings::domStencil_op::domZfail::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_stencil_op_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_op::domZfail , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "KEEP"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_op::domZfail , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_op::domZfail)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_op::domZpass::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_op::domZpassRef ref = new domGl_pipeline_settings::domStencil_op::domZpass(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_op::domZpass::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "zpass" ); + meta->registerClass(domGl_pipeline_settings::domStencil_op::domZpass::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_stencil_op_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_op::domZpass , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "KEEP"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_op::domZpass , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_op::domZpass)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_func_separate::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_func_separateRef ref = new domGl_pipeline_settings::domStencil_func_separate(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_func_separate::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "stencil_func_separate" ); + meta->registerClass(domGl_pipeline_settings::domStencil_func_separate::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "front" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_func_separate,elemFront) ); + mea->setElementType( domGl_pipeline_settings::domStencil_func_separate::domFront::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "back" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_func_separate,elemBack) ); + mea->setElementType( domGl_pipeline_settings::domStencil_func_separate::domBack::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 1, 1 ); + mea->setName( "ref" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_func_separate,elemRef) ); + mea->setElementType( domGl_pipeline_settings::domStencil_func_separate::domRef::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 1, 1 ); + mea->setName( "mask" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_func_separate,elemMask) ); + mea->setElementType( domGl_pipeline_settings::domStencil_func_separate::domMask::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_func_separate)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_func_separate::domFront::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_func_separate::domFrontRef ref = new domGl_pipeline_settings::domStencil_func_separate::domFront(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_func_separate::domFront::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "front" ); + meta->registerClass(domGl_pipeline_settings::domStencil_func_separate::domFront::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_func_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_func_separate::domFront , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ALWAYS"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_func_separate::domFront , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_func_separate::domFront)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_func_separate::domBack::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_func_separate::domBackRef ref = new domGl_pipeline_settings::domStencil_func_separate::domBack(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_func_separate::domBack::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "back" ); + meta->registerClass(domGl_pipeline_settings::domStencil_func_separate::domBack::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_func_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_func_separate::domBack , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ALWAYS"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_func_separate::domBack , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_func_separate::domBack)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_func_separate::domRef::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_func_separate::domRefRef ref = new domGl_pipeline_settings::domStencil_func_separate::domRef(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_func_separate::domRef::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "ref" ); + meta->registerClass(domGl_pipeline_settings::domStencil_func_separate::domRef::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedByte")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_func_separate::domRef , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_func_separate::domRef , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_func_separate::domRef)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_func_separate::domMask::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_func_separate::domMaskRef ref = new domGl_pipeline_settings::domStencil_func_separate::domMask(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_func_separate::domMask::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mask" ); + meta->registerClass(domGl_pipeline_settings::domStencil_func_separate::domMask::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedByte")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_func_separate::domMask , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "255"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_func_separate::domMask , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_func_separate::domMask)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_op_separate::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_op_separateRef ref = new domGl_pipeline_settings::domStencil_op_separate(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_op_separate::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "stencil_op_separate" ); + meta->registerClass(domGl_pipeline_settings::domStencil_op_separate::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "face" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_op_separate,elemFace) ); + mea->setElementType( domGl_pipeline_settings::domStencil_op_separate::domFace::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "fail" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_op_separate,elemFail) ); + mea->setElementType( domGl_pipeline_settings::domStencil_op_separate::domFail::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 1, 1 ); + mea->setName( "zfail" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_op_separate,elemZfail) ); + mea->setElementType( domGl_pipeline_settings::domStencil_op_separate::domZfail::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 1, 1 ); + mea->setName( "zpass" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_op_separate,elemZpass) ); + mea->setElementType( domGl_pipeline_settings::domStencil_op_separate::domZpass::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_op_separate)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_op_separate::domFace::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_op_separate::domFaceRef ref = new domGl_pipeline_settings::domStencil_op_separate::domFace(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_op_separate::domFace::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "face" ); + meta->registerClass(domGl_pipeline_settings::domStencil_op_separate::domFace::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_face_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_op_separate::domFace , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "FRONT_AND_BACK"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_op_separate::domFace , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_op_separate::domFace)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_op_separate::domFail::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_op_separate::domFailRef ref = new domGl_pipeline_settings::domStencil_op_separate::domFail(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_op_separate::domFail::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fail" ); + meta->registerClass(domGl_pipeline_settings::domStencil_op_separate::domFail::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_stencil_op_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_op_separate::domFail , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "KEEP"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_op_separate::domFail , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_op_separate::domFail)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_op_separate::domZfail::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_op_separate::domZfailRef ref = new domGl_pipeline_settings::domStencil_op_separate::domZfail(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_op_separate::domZfail::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "zfail" ); + meta->registerClass(domGl_pipeline_settings::domStencil_op_separate::domZfail::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_stencil_op_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_op_separate::domZfail , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "KEEP"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_op_separate::domZfail , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_op_separate::domZfail)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_op_separate::domZpass::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_op_separate::domZpassRef ref = new domGl_pipeline_settings::domStencil_op_separate::domZpass(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_op_separate::domZpass::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "zpass" ); + meta->registerClass(domGl_pipeline_settings::domStencil_op_separate::domZpass::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_stencil_op_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_op_separate::domZpass , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "KEEP"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_op_separate::domZpass , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_op_separate::domZpass)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_mask_separate::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_mask_separateRef ref = new domGl_pipeline_settings::domStencil_mask_separate(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_mask_separate::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "stencil_mask_separate" ); + meta->registerClass(domGl_pipeline_settings::domStencil_mask_separate::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "face" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_mask_separate,elemFace) ); + mea->setElementType( domGl_pipeline_settings::domStencil_mask_separate::domFace::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "mask" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domStencil_mask_separate,elemMask) ); + mea->setElementType( domGl_pipeline_settings::domStencil_mask_separate::domMask::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_mask_separate)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_mask_separate::domFace::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_mask_separate::domFaceRef ref = new domGl_pipeline_settings::domStencil_mask_separate::domFace(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_mask_separate::domFace::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "face" ); + meta->registerClass(domGl_pipeline_settings::domStencil_mask_separate::domFace::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_face_type")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_mask_separate::domFace , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "FRONT_AND_BACK"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_mask_separate::domFace , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_mask_separate::domFace)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_mask_separate::domMask::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_mask_separate::domMaskRef ref = new domGl_pipeline_settings::domStencil_mask_separate::domMask(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_mask_separate::domMask::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mask" ); + meta->registerClass(domGl_pipeline_settings::domStencil_mask_separate::domMask::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedByte")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_mask_separate::domMask , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "255"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_mask_separate::domMask , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_mask_separate::domMask)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLight_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domLight_enableRef ref = new domGl_pipeline_settings::domLight_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLight_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_enable" ); + meta->registerClass(domGl_pipeline_settings::domLight_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_enable , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLight_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLight_ambient::create(DAE& dae) +{ + domGl_pipeline_settings::domLight_ambientRef ref = new domGl_pipeline_settings::domLight_ambient(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLight_ambient::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_ambient" ); + meta->registerClass(domGl_pipeline_settings::domLight_ambient::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_ambient , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 0 1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_ambient , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_ambient , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLight_ambient)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLight_diffuse::create(DAE& dae) +{ + domGl_pipeline_settings::domLight_diffuseRef ref = new domGl_pipeline_settings::domLight_diffuse(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLight_diffuse::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_diffuse" ); + meta->registerClass(domGl_pipeline_settings::domLight_diffuse::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_diffuse , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 0 0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_diffuse , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_diffuse , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLight_diffuse)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLight_specular::create(DAE& dae) +{ + domGl_pipeline_settings::domLight_specularRef ref = new domGl_pipeline_settings::domLight_specular(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLight_specular::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_specular" ); + meta->registerClass(domGl_pipeline_settings::domLight_specular::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_specular , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 0 0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_specular , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_specular , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLight_specular)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLight_position::create(DAE& dae) +{ + domGl_pipeline_settings::domLight_positionRef ref = new domGl_pipeline_settings::domLight_position(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLight_position::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_position" ); + meta->registerClass(domGl_pipeline_settings::domLight_position::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_position , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 1 0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_position , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_position , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLight_position)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLight_constant_attenuation::create(DAE& dae) +{ + domGl_pipeline_settings::domLight_constant_attenuationRef ref = new domGl_pipeline_settings::domLight_constant_attenuation(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLight_constant_attenuation::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_constant_attenuation" ); + meta->registerClass(domGl_pipeline_settings::domLight_constant_attenuation::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_constant_attenuation , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_constant_attenuation , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_constant_attenuation , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLight_constant_attenuation)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLight_linear_attenuation::create(DAE& dae) +{ + domGl_pipeline_settings::domLight_linear_attenuationRef ref = new domGl_pipeline_settings::domLight_linear_attenuation(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLight_linear_attenuation::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_linear_attenuation" ); + meta->registerClass(domGl_pipeline_settings::domLight_linear_attenuation::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_linear_attenuation , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_linear_attenuation , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_linear_attenuation , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLight_linear_attenuation)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLight_quadratic_attenuation::create(DAE& dae) +{ + domGl_pipeline_settings::domLight_quadratic_attenuationRef ref = new domGl_pipeline_settings::domLight_quadratic_attenuation(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLight_quadratic_attenuation::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_quadratic_attenuation" ); + meta->registerClass(domGl_pipeline_settings::domLight_quadratic_attenuation::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_quadratic_attenuation , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_quadratic_attenuation , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_quadratic_attenuation , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLight_quadratic_attenuation)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLight_spot_cutoff::create(DAE& dae) +{ + domGl_pipeline_settings::domLight_spot_cutoffRef ref = new domGl_pipeline_settings::domLight_spot_cutoff(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLight_spot_cutoff::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_spot_cutoff" ); + meta->registerClass(domGl_pipeline_settings::domLight_spot_cutoff::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_spot_cutoff , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "180"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_spot_cutoff , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_spot_cutoff , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLight_spot_cutoff)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLight_spot_direction::create(DAE& dae) +{ + domGl_pipeline_settings::domLight_spot_directionRef ref = new domGl_pipeline_settings::domLight_spot_direction(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLight_spot_direction::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_spot_direction" ); + meta->registerClass(domGl_pipeline_settings::domLight_spot_direction::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_spot_direction , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 -1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_spot_direction , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_spot_direction , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLight_spot_direction)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLight_spot_exponent::create(DAE& dae) +{ + domGl_pipeline_settings::domLight_spot_exponentRef ref = new domGl_pipeline_settings::domLight_spot_exponent(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLight_spot_exponent::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_spot_exponent" ); + meta->registerClass(domGl_pipeline_settings::domLight_spot_exponent::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_spot_exponent , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_spot_exponent , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_spot_exponent , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLight_spot_exponent)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTexture1D::create(DAE& dae) +{ + domGl_pipeline_settings::domTexture1DRef ref = new domGl_pipeline_settings::domTexture1D(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTexture1D::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "texture1D" ); + meta->registerClass(domGl_pipeline_settings::domTexture1D::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "value" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domTexture1D,elemValue) ); + mea->setElementType( domGl_sampler1D::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "param" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domTexture1D,elemParam) ); + mea->setElementType( domGl_pipeline_settings::domTexture1D::domParam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGl_pipeline_settings::domTexture1D,_contents)); + meta->addContentsOrder(daeOffsetOf(domGl_pipeline_settings::domTexture1D,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGl_pipeline_settings::domTexture1D,_CMData), 1); + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_TEXTURE_IMAGE_UNITS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture1D , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTexture1D)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTexture1D::domParam::create(DAE& dae) +{ + domGl_pipeline_settings::domTexture1D::domParamRef ref = new domGl_pipeline_settings::domTexture1D::domParam(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTexture1D::domParam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "param" ); + meta->registerClass(domGl_pipeline_settings::domTexture1D::domParam::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture1D::domParam , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTexture1D::domParam)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTexture2D::create(DAE& dae) +{ + domGl_pipeline_settings::domTexture2DRef ref = new domGl_pipeline_settings::domTexture2D(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTexture2D::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "texture2D" ); + meta->registerClass(domGl_pipeline_settings::domTexture2D::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "value" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domTexture2D,elemValue) ); + mea->setElementType( domGl_sampler2D::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "param" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domTexture2D,elemParam) ); + mea->setElementType( domGl_pipeline_settings::domTexture2D::domParam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGl_pipeline_settings::domTexture2D,_contents)); + meta->addContentsOrder(daeOffsetOf(domGl_pipeline_settings::domTexture2D,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGl_pipeline_settings::domTexture2D,_CMData), 1); + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_TEXTURE_IMAGE_UNITS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture2D , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTexture2D)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTexture2D::domParam::create(DAE& dae) +{ + domGl_pipeline_settings::domTexture2D::domParamRef ref = new domGl_pipeline_settings::domTexture2D::domParam(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTexture2D::domParam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "param" ); + meta->registerClass(domGl_pipeline_settings::domTexture2D::domParam::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture2D::domParam , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTexture2D::domParam)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTexture3D::create(DAE& dae) +{ + domGl_pipeline_settings::domTexture3DRef ref = new domGl_pipeline_settings::domTexture3D(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTexture3D::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "texture3D" ); + meta->registerClass(domGl_pipeline_settings::domTexture3D::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "value" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domTexture3D,elemValue) ); + mea->setElementType( domGl_sampler3D::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "param" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domTexture3D,elemParam) ); + mea->setElementType( domGl_pipeline_settings::domTexture3D::domParam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGl_pipeline_settings::domTexture3D,_contents)); + meta->addContentsOrder(daeOffsetOf(domGl_pipeline_settings::domTexture3D,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGl_pipeline_settings::domTexture3D,_CMData), 1); + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_TEXTURE_IMAGE_UNITS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture3D , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTexture3D)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTexture3D::domParam::create(DAE& dae) +{ + domGl_pipeline_settings::domTexture3D::domParamRef ref = new domGl_pipeline_settings::domTexture3D::domParam(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTexture3D::domParam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "param" ); + meta->registerClass(domGl_pipeline_settings::domTexture3D::domParam::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture3D::domParam , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTexture3D::domParam)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTextureCUBE::create(DAE& dae) +{ + domGl_pipeline_settings::domTextureCUBERef ref = new domGl_pipeline_settings::domTextureCUBE(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTextureCUBE::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "textureCUBE" ); + meta->registerClass(domGl_pipeline_settings::domTextureCUBE::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "value" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domTextureCUBE,elemValue) ); + mea->setElementType( domGl_samplerCUBE::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "param" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domTextureCUBE,elemParam) ); + mea->setElementType( domGl_pipeline_settings::domTextureCUBE::domParam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGl_pipeline_settings::domTextureCUBE,_contents)); + meta->addContentsOrder(daeOffsetOf(domGl_pipeline_settings::domTextureCUBE,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGl_pipeline_settings::domTextureCUBE,_CMData), 1); + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_TEXTURE_IMAGE_UNITS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTextureCUBE , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTextureCUBE)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTextureCUBE::domParam::create(DAE& dae) +{ + domGl_pipeline_settings::domTextureCUBE::domParamRef ref = new domGl_pipeline_settings::domTextureCUBE::domParam(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTextureCUBE::domParam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "param" ); + meta->registerClass(domGl_pipeline_settings::domTextureCUBE::domParam::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTextureCUBE::domParam , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTextureCUBE::domParam)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTextureRECT::create(DAE& dae) +{ + domGl_pipeline_settings::domTextureRECTRef ref = new domGl_pipeline_settings::domTextureRECT(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTextureRECT::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "textureRECT" ); + meta->registerClass(domGl_pipeline_settings::domTextureRECT::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "value" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domTextureRECT,elemValue) ); + mea->setElementType( domGl_samplerRECT::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "param" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domTextureRECT,elemParam) ); + mea->setElementType( domGl_pipeline_settings::domTextureRECT::domParam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGl_pipeline_settings::domTextureRECT,_contents)); + meta->addContentsOrder(daeOffsetOf(domGl_pipeline_settings::domTextureRECT,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGl_pipeline_settings::domTextureRECT,_CMData), 1); + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_TEXTURE_IMAGE_UNITS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTextureRECT , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTextureRECT)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTextureRECT::domParam::create(DAE& dae) +{ + domGl_pipeline_settings::domTextureRECT::domParamRef ref = new domGl_pipeline_settings::domTextureRECT::domParam(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTextureRECT::domParam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "param" ); + meta->registerClass(domGl_pipeline_settings::domTextureRECT::domParam::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTextureRECT::domParam , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTextureRECT::domParam)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTextureDEPTH::create(DAE& dae) +{ + domGl_pipeline_settings::domTextureDEPTHRef ref = new domGl_pipeline_settings::domTextureDEPTH(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTextureDEPTH::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "textureDEPTH" ); + meta->registerClass(domGl_pipeline_settings::domTextureDEPTH::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "value" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domTextureDEPTH,elemValue) ); + mea->setElementType( domGl_samplerDEPTH::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "param" ); + mea->setOffset( daeOffsetOf(domGl_pipeline_settings::domTextureDEPTH,elemParam) ); + mea->setElementType( domGl_pipeline_settings::domTextureDEPTH::domParam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGl_pipeline_settings::domTextureDEPTH,_contents)); + meta->addContentsOrder(daeOffsetOf(domGl_pipeline_settings::domTextureDEPTH,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGl_pipeline_settings::domTextureDEPTH,_CMData), 1); + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_TEXTURE_IMAGE_UNITS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTextureDEPTH , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTextureDEPTH)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTextureDEPTH::domParam::create(DAE& dae) +{ + domGl_pipeline_settings::domTextureDEPTH::domParamRef ref = new domGl_pipeline_settings::domTextureDEPTH::domParam(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTextureDEPTH::domParam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "param" ); + meta->registerClass(domGl_pipeline_settings::domTextureDEPTH::domParam::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTextureDEPTH::domParam , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTextureDEPTH::domParam)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTexture1D_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domTexture1D_enableRef ref = new domGl_pipeline_settings::domTexture1D_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTexture1D_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "texture1D_enable" ); + meta->registerClass(domGl_pipeline_settings::domTexture1D_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture1D_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture1D_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_TEXTURE_IMAGE_UNITS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture1D_enable , attrIndex )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTexture1D_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTexture2D_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domTexture2D_enableRef ref = new domGl_pipeline_settings::domTexture2D_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTexture2D_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "texture2D_enable" ); + meta->registerClass(domGl_pipeline_settings::domTexture2D_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture2D_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture2D_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_TEXTURE_IMAGE_UNITS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture2D_enable , attrIndex )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTexture2D_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTexture3D_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domTexture3D_enableRef ref = new domGl_pipeline_settings::domTexture3D_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTexture3D_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "texture3D_enable" ); + meta->registerClass(domGl_pipeline_settings::domTexture3D_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture3D_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture3D_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_TEXTURE_IMAGE_UNITS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture3D_enable , attrIndex )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTexture3D_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTextureCUBE_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domTextureCUBE_enableRef ref = new domGl_pipeline_settings::domTextureCUBE_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTextureCUBE_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "textureCUBE_enable" ); + meta->registerClass(domGl_pipeline_settings::domTextureCUBE_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTextureCUBE_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTextureCUBE_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_TEXTURE_IMAGE_UNITS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTextureCUBE_enable , attrIndex )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTextureCUBE_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTextureRECT_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domTextureRECT_enableRef ref = new domGl_pipeline_settings::domTextureRECT_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTextureRECT_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "textureRECT_enable" ); + meta->registerClass(domGl_pipeline_settings::domTextureRECT_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTextureRECT_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTextureRECT_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_TEXTURE_IMAGE_UNITS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTextureRECT_enable , attrIndex )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTextureRECT_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTextureDEPTH_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domTextureDEPTH_enableRef ref = new domGl_pipeline_settings::domTextureDEPTH_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTextureDEPTH_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "textureDEPTH_enable" ); + meta->registerClass(domGl_pipeline_settings::domTextureDEPTH_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTextureDEPTH_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTextureDEPTH_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_TEXTURE_IMAGE_UNITS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTextureDEPTH_enable , attrIndex )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTextureDEPTH_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTexture_env_color::create(DAE& dae) +{ + domGl_pipeline_settings::domTexture_env_colorRef ref = new domGl_pipeline_settings::domTexture_env_color(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTexture_env_color::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "texture_env_color" ); + meta->registerClass(domGl_pipeline_settings::domTexture_env_color::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture_env_color , attrValue )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture_env_color , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_TEXTURE_IMAGE_UNITS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture_env_color , attrIndex )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTexture_env_color)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domTexture_env_mode::create(DAE& dae) +{ + domGl_pipeline_settings::domTexture_env_modeRef ref = new domGl_pipeline_settings::domTexture_env_mode(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domTexture_env_mode::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "texture_env_mode" ); + meta->registerClass(domGl_pipeline_settings::domTexture_env_mode::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("String")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture_env_mode , attrValue )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture_env_mode , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_TEXTURE_IMAGE_UNITS_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domTexture_env_mode , attrIndex )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domTexture_env_mode)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domClip_plane::create(DAE& dae) +{ + domGl_pipeline_settings::domClip_planeRef ref = new domGl_pipeline_settings::domClip_plane(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domClip_plane::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "clip_plane" ); + meta->registerClass(domGl_pipeline_settings::domClip_plane::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domClip_plane , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 0 0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domClip_plane , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_CLIP_PLANES_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domClip_plane , attrIndex )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domClip_plane)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domClip_plane_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domClip_plane_enableRef ref = new domGl_pipeline_settings::domClip_plane_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domClip_plane_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "clip_plane_enable" ); + meta->registerClass(domGl_pipeline_settings::domClip_plane_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domClip_plane_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domClip_plane_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GL_MAX_CLIP_PLANES_index")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domClip_plane_enable , attrIndex )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domClip_plane_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domBlend_color::create(DAE& dae) +{ + domGl_pipeline_settings::domBlend_colorRef ref = new domGl_pipeline_settings::domBlend_color(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domBlend_color::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "blend_color" ); + meta->registerClass(domGl_pipeline_settings::domBlend_color::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_color , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 0 0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_color , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domBlend_color)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domClear_color::create(DAE& dae) +{ + domGl_pipeline_settings::domClear_colorRef ref = new domGl_pipeline_settings::domClear_color(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domClear_color::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "clear_color" ); + meta->registerClass(domGl_pipeline_settings::domClear_color::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domClear_color , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 0 0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domClear_color , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domClear_color)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domClear_stencil::create(DAE& dae) +{ + domGl_pipeline_settings::domClear_stencilRef ref = new domGl_pipeline_settings::domClear_stencil(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domClear_stencil::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "clear_stencil" ); + meta->registerClass(domGl_pipeline_settings::domClear_stencil::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Int")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domClear_stencil , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domClear_stencil , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domClear_stencil)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domClear_depth::create(DAE& dae) +{ + domGl_pipeline_settings::domClear_depthRef ref = new domGl_pipeline_settings::domClear_depth(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domClear_depth::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "clear_depth" ); + meta->registerClass(domGl_pipeline_settings::domClear_depth::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domClear_depth , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domClear_depth , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domClear_depth)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domColor_mask::create(DAE& dae) +{ + domGl_pipeline_settings::domColor_maskRef ref = new domGl_pipeline_settings::domColor_mask(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domColor_mask::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "color_mask" ); + meta->registerClass(domGl_pipeline_settings::domColor_mask::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domColor_mask , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "true true true true"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domColor_mask , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domColor_mask)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domDepth_bounds::create(DAE& dae) +{ + domGl_pipeline_settings::domDepth_boundsRef ref = new domGl_pipeline_settings::domDepth_bounds(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domDepth_bounds::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "depth_bounds" ); + meta->registerClass(domGl_pipeline_settings::domDepth_bounds::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDepth_bounds , attrValue )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDepth_bounds , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domDepth_bounds)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domDepth_mask::create(DAE& dae) +{ + domGl_pipeline_settings::domDepth_maskRef ref = new domGl_pipeline_settings::domDepth_mask(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domDepth_mask::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "depth_mask" ); + meta->registerClass(domGl_pipeline_settings::domDepth_mask::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDepth_mask , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "true"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDepth_mask , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domDepth_mask)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domDepth_range::create(DAE& dae) +{ + domGl_pipeline_settings::domDepth_rangeRef ref = new domGl_pipeline_settings::domDepth_range(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domDepth_range::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "depth_range" ); + meta->registerClass(domGl_pipeline_settings::domDepth_range::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDepth_range , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDepth_range , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domDepth_range)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domFog_density::create(DAE& dae) +{ + domGl_pipeline_settings::domFog_densityRef ref = new domGl_pipeline_settings::domFog_density(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domFog_density::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fog_density" ); + meta->registerClass(domGl_pipeline_settings::domFog_density::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFog_density , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFog_density , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domFog_density)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domFog_start::create(DAE& dae) +{ + domGl_pipeline_settings::domFog_startRef ref = new domGl_pipeline_settings::domFog_start(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domFog_start::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fog_start" ); + meta->registerClass(domGl_pipeline_settings::domFog_start::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFog_start , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFog_start , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domFog_start)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domFog_end::create(DAE& dae) +{ + domGl_pipeline_settings::domFog_endRef ref = new domGl_pipeline_settings::domFog_end(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domFog_end::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fog_end" ); + meta->registerClass(domGl_pipeline_settings::domFog_end::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFog_end , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFog_end , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domFog_end)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domFog_color::create(DAE& dae) +{ + domGl_pipeline_settings::domFog_colorRef ref = new domGl_pipeline_settings::domFog_color(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domFog_color::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fog_color" ); + meta->registerClass(domGl_pipeline_settings::domFog_color::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFog_color , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 0 0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFog_color , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domFog_color)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLight_model_ambient::create(DAE& dae) +{ + domGl_pipeline_settings::domLight_model_ambientRef ref = new domGl_pipeline_settings::domLight_model_ambient(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLight_model_ambient::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_model_ambient" ); + meta->registerClass(domGl_pipeline_settings::domLight_model_ambient::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_model_ambient , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0.2 0.2 0.2 1.0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_model_ambient , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLight_model_ambient)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLighting_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domLighting_enableRef ref = new domGl_pipeline_settings::domLighting_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLighting_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "lighting_enable" ); + meta->registerClass(domGl_pipeline_settings::domLighting_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLighting_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLighting_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLighting_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLine_stipple::create(DAE& dae) +{ + domGl_pipeline_settings::domLine_stippleRef ref = new domGl_pipeline_settings::domLine_stipple(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLine_stipple::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "line_stipple" ); + meta->registerClass(domGl_pipeline_settings::domLine_stipple::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Int2")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLine_stipple , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1 65536"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLine_stipple , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLine_stipple)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLine_width::create(DAE& dae) +{ + domGl_pipeline_settings::domLine_widthRef ref = new domGl_pipeline_settings::domLine_width(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLine_width::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "line_width" ); + meta->registerClass(domGl_pipeline_settings::domLine_width::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLine_width , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLine_width , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLine_width)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domMaterial_ambient::create(DAE& dae) +{ + domGl_pipeline_settings::domMaterial_ambientRef ref = new domGl_pipeline_settings::domMaterial_ambient(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domMaterial_ambient::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "material_ambient" ); + meta->registerClass(domGl_pipeline_settings::domMaterial_ambient::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domMaterial_ambient , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0.2 0.2 0.2 1.0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domMaterial_ambient , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domMaterial_ambient)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domMaterial_diffuse::create(DAE& dae) +{ + domGl_pipeline_settings::domMaterial_diffuseRef ref = new domGl_pipeline_settings::domMaterial_diffuse(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domMaterial_diffuse::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "material_diffuse" ); + meta->registerClass(domGl_pipeline_settings::domMaterial_diffuse::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domMaterial_diffuse , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0.8 0.8 0.8 1.0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domMaterial_diffuse , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domMaterial_diffuse)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domMaterial_emission::create(DAE& dae) +{ + domGl_pipeline_settings::domMaterial_emissionRef ref = new domGl_pipeline_settings::domMaterial_emission(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domMaterial_emission::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "material_emission" ); + meta->registerClass(domGl_pipeline_settings::domMaterial_emission::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domMaterial_emission , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 0 1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domMaterial_emission , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domMaterial_emission)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domMaterial_shininess::create(DAE& dae) +{ + domGl_pipeline_settings::domMaterial_shininessRef ref = new domGl_pipeline_settings::domMaterial_shininess(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domMaterial_shininess::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "material_shininess" ); + meta->registerClass(domGl_pipeline_settings::domMaterial_shininess::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domMaterial_shininess , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domMaterial_shininess , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domMaterial_shininess)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domMaterial_specular::create(DAE& dae) +{ + domGl_pipeline_settings::domMaterial_specularRef ref = new domGl_pipeline_settings::domMaterial_specular(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domMaterial_specular::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "material_specular" ); + meta->registerClass(domGl_pipeline_settings::domMaterial_specular::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domMaterial_specular , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 0 1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domMaterial_specular , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domMaterial_specular)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domModel_view_matrix::create(DAE& dae) +{ + domGl_pipeline_settings::domModel_view_matrixRef ref = new domGl_pipeline_settings::domModel_view_matrix(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domModel_view_matrix::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "model_view_matrix" ); + meta->registerClass(domGl_pipeline_settings::domModel_view_matrix::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4x4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domModel_view_matrix , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domModel_view_matrix , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domModel_view_matrix)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domPoint_distance_attenuation::create(DAE& dae) +{ + domGl_pipeline_settings::domPoint_distance_attenuationRef ref = new domGl_pipeline_settings::domPoint_distance_attenuation(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domPoint_distance_attenuation::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "point_distance_attenuation" ); + meta->registerClass(domGl_pipeline_settings::domPoint_distance_attenuation::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPoint_distance_attenuation , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1 0 0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPoint_distance_attenuation , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domPoint_distance_attenuation)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domPoint_fade_threshold_size::create(DAE& dae) +{ + domGl_pipeline_settings::domPoint_fade_threshold_sizeRef ref = new domGl_pipeline_settings::domPoint_fade_threshold_size(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domPoint_fade_threshold_size::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "point_fade_threshold_size" ); + meta->registerClass(domGl_pipeline_settings::domPoint_fade_threshold_size::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPoint_fade_threshold_size , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPoint_fade_threshold_size , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domPoint_fade_threshold_size)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domPoint_size::create(DAE& dae) +{ + domGl_pipeline_settings::domPoint_sizeRef ref = new domGl_pipeline_settings::domPoint_size(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domPoint_size::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "point_size" ); + meta->registerClass(domGl_pipeline_settings::domPoint_size::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPoint_size , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPoint_size , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domPoint_size)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domPoint_size_min::create(DAE& dae) +{ + domGl_pipeline_settings::domPoint_size_minRef ref = new domGl_pipeline_settings::domPoint_size_min(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domPoint_size_min::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "point_size_min" ); + meta->registerClass(domGl_pipeline_settings::domPoint_size_min::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPoint_size_min , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPoint_size_min , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domPoint_size_min)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domPoint_size_max::create(DAE& dae) +{ + domGl_pipeline_settings::domPoint_size_maxRef ref = new domGl_pipeline_settings::domPoint_size_max(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domPoint_size_max::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "point_size_max" ); + meta->registerClass(domGl_pipeline_settings::domPoint_size_max::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPoint_size_max , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPoint_size_max , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domPoint_size_max)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domPolygon_offset::create(DAE& dae) +{ + domGl_pipeline_settings::domPolygon_offsetRef ref = new domGl_pipeline_settings::domPolygon_offset(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domPolygon_offset::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "polygon_offset" ); + meta->registerClass(domGl_pipeline_settings::domPolygon_offset::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_offset , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_offset , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domPolygon_offset)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domProjection_matrix::create(DAE& dae) +{ + domGl_pipeline_settings::domProjection_matrixRef ref = new domGl_pipeline_settings::domProjection_matrix(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domProjection_matrix::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "projection_matrix" ); + meta->registerClass(domGl_pipeline_settings::domProjection_matrix::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4x4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domProjection_matrix , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domProjection_matrix , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domProjection_matrix)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domScissor::create(DAE& dae) +{ + domGl_pipeline_settings::domScissorRef ref = new domGl_pipeline_settings::domScissor(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domScissor::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "scissor" ); + meta->registerClass(domGl_pipeline_settings::domScissor::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Int4")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domScissor , attrValue )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domScissor , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domScissor)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_mask::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_maskRef ref = new domGl_pipeline_settings::domStencil_mask(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_mask::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "stencil_mask" ); + meta->registerClass(domGl_pipeline_settings::domStencil_mask::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Int")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_mask , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "4294967295"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_mask , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_mask)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domAlpha_test_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domAlpha_test_enableRef ref = new domGl_pipeline_settings::domAlpha_test_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domAlpha_test_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "alpha_test_enable" ); + meta->registerClass(domGl_pipeline_settings::domAlpha_test_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domAlpha_test_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domAlpha_test_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domAlpha_test_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domAuto_normal_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domAuto_normal_enableRef ref = new domGl_pipeline_settings::domAuto_normal_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domAuto_normal_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "auto_normal_enable" ); + meta->registerClass(domGl_pipeline_settings::domAuto_normal_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domAuto_normal_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domAuto_normal_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domAuto_normal_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domBlend_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domBlend_enableRef ref = new domGl_pipeline_settings::domBlend_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domBlend_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "blend_enable" ); + meta->registerClass(domGl_pipeline_settings::domBlend_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domBlend_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domBlend_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domColor_logic_op_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domColor_logic_op_enableRef ref = new domGl_pipeline_settings::domColor_logic_op_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domColor_logic_op_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "color_logic_op_enable" ); + meta->registerClass(domGl_pipeline_settings::domColor_logic_op_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domColor_logic_op_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domColor_logic_op_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domColor_logic_op_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domColor_material_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domColor_material_enableRef ref = new domGl_pipeline_settings::domColor_material_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domColor_material_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "color_material_enable" ); + meta->registerClass(domGl_pipeline_settings::domColor_material_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domColor_material_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "true"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domColor_material_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domColor_material_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domCull_face_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domCull_face_enableRef ref = new domGl_pipeline_settings::domCull_face_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domCull_face_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cull_face_enable" ); + meta->registerClass(domGl_pipeline_settings::domCull_face_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domCull_face_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domCull_face_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domCull_face_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domDepth_bounds_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domDepth_bounds_enableRef ref = new domGl_pipeline_settings::domDepth_bounds_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domDepth_bounds_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "depth_bounds_enable" ); + meta->registerClass(domGl_pipeline_settings::domDepth_bounds_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDepth_bounds_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDepth_bounds_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domDepth_bounds_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domDepth_clamp_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domDepth_clamp_enableRef ref = new domGl_pipeline_settings::domDepth_clamp_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domDepth_clamp_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "depth_clamp_enable" ); + meta->registerClass(domGl_pipeline_settings::domDepth_clamp_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDepth_clamp_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDepth_clamp_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domDepth_clamp_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domDepth_test_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domDepth_test_enableRef ref = new domGl_pipeline_settings::domDepth_test_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domDepth_test_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "depth_test_enable" ); + meta->registerClass(domGl_pipeline_settings::domDepth_test_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDepth_test_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDepth_test_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domDepth_test_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domDither_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domDither_enableRef ref = new domGl_pipeline_settings::domDither_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domDither_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "dither_enable" ); + meta->registerClass(domGl_pipeline_settings::domDither_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDither_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "true"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domDither_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domDither_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domFog_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domFog_enableRef ref = new domGl_pipeline_settings::domFog_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domFog_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fog_enable" ); + meta->registerClass(domGl_pipeline_settings::domFog_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFog_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domFog_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domFog_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLight_model_local_viewer_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domLight_model_local_viewer_enableRef ref = new domGl_pipeline_settings::domLight_model_local_viewer_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLight_model_local_viewer_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_model_local_viewer_enable" ); + meta->registerClass(domGl_pipeline_settings::domLight_model_local_viewer_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_model_local_viewer_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_model_local_viewer_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLight_model_local_viewer_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLight_model_two_side_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domLight_model_two_side_enableRef ref = new domGl_pipeline_settings::domLight_model_two_side_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLight_model_two_side_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_model_two_side_enable" ); + meta->registerClass(domGl_pipeline_settings::domLight_model_two_side_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_model_two_side_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLight_model_two_side_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLight_model_two_side_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLine_smooth_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domLine_smooth_enableRef ref = new domGl_pipeline_settings::domLine_smooth_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLine_smooth_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "line_smooth_enable" ); + meta->registerClass(domGl_pipeline_settings::domLine_smooth_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLine_smooth_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLine_smooth_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLine_smooth_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLine_stipple_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domLine_stipple_enableRef ref = new domGl_pipeline_settings::domLine_stipple_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLine_stipple_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "line_stipple_enable" ); + meta->registerClass(domGl_pipeline_settings::domLine_stipple_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLine_stipple_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLine_stipple_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLine_stipple_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domLogic_op_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domLogic_op_enableRef ref = new domGl_pipeline_settings::domLogic_op_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domLogic_op_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "logic_op_enable" ); + meta->registerClass(domGl_pipeline_settings::domLogic_op_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLogic_op_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domLogic_op_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domLogic_op_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domMultisample_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domMultisample_enableRef ref = new domGl_pipeline_settings::domMultisample_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domMultisample_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "multisample_enable" ); + meta->registerClass(domGl_pipeline_settings::domMultisample_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domMultisample_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domMultisample_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domMultisample_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domNormalize_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domNormalize_enableRef ref = new domGl_pipeline_settings::domNormalize_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domNormalize_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "normalize_enable" ); + meta->registerClass(domGl_pipeline_settings::domNormalize_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domNormalize_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domNormalize_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domNormalize_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domPoint_smooth_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domPoint_smooth_enableRef ref = new domGl_pipeline_settings::domPoint_smooth_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domPoint_smooth_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "point_smooth_enable" ); + meta->registerClass(domGl_pipeline_settings::domPoint_smooth_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPoint_smooth_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPoint_smooth_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domPoint_smooth_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domPolygon_offset_fill_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domPolygon_offset_fill_enableRef ref = new domGl_pipeline_settings::domPolygon_offset_fill_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domPolygon_offset_fill_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "polygon_offset_fill_enable" ); + meta->registerClass(domGl_pipeline_settings::domPolygon_offset_fill_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_offset_fill_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_offset_fill_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domPolygon_offset_fill_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domPolygon_offset_line_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domPolygon_offset_line_enableRef ref = new domGl_pipeline_settings::domPolygon_offset_line_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domPolygon_offset_line_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "polygon_offset_line_enable" ); + meta->registerClass(domGl_pipeline_settings::domPolygon_offset_line_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_offset_line_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_offset_line_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domPolygon_offset_line_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domPolygon_offset_point_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domPolygon_offset_point_enableRef ref = new domGl_pipeline_settings::domPolygon_offset_point_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domPolygon_offset_point_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "polygon_offset_point_enable" ); + meta->registerClass(domGl_pipeline_settings::domPolygon_offset_point_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_offset_point_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_offset_point_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domPolygon_offset_point_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domPolygon_smooth_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domPolygon_smooth_enableRef ref = new domGl_pipeline_settings::domPolygon_smooth_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domPolygon_smooth_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "polygon_smooth_enable" ); + meta->registerClass(domGl_pipeline_settings::domPolygon_smooth_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_smooth_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_smooth_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domPolygon_smooth_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domPolygon_stipple_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domPolygon_stipple_enableRef ref = new domGl_pipeline_settings::domPolygon_stipple_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domPolygon_stipple_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "polygon_stipple_enable" ); + meta->registerClass(domGl_pipeline_settings::domPolygon_stipple_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_stipple_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domPolygon_stipple_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domPolygon_stipple_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domRescale_normal_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domRescale_normal_enableRef ref = new domGl_pipeline_settings::domRescale_normal_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domRescale_normal_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "rescale_normal_enable" ); + meta->registerClass(domGl_pipeline_settings::domRescale_normal_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domRescale_normal_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domRescale_normal_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domRescale_normal_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domSample_alpha_to_coverage_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domSample_alpha_to_coverage_enableRef ref = new domGl_pipeline_settings::domSample_alpha_to_coverage_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domSample_alpha_to_coverage_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "sample_alpha_to_coverage_enable" ); + meta->registerClass(domGl_pipeline_settings::domSample_alpha_to_coverage_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domSample_alpha_to_coverage_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domSample_alpha_to_coverage_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domSample_alpha_to_coverage_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domSample_alpha_to_one_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domSample_alpha_to_one_enableRef ref = new domGl_pipeline_settings::domSample_alpha_to_one_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domSample_alpha_to_one_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "sample_alpha_to_one_enable" ); + meta->registerClass(domGl_pipeline_settings::domSample_alpha_to_one_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domSample_alpha_to_one_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domSample_alpha_to_one_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domSample_alpha_to_one_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domSample_coverage_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domSample_coverage_enableRef ref = new domGl_pipeline_settings::domSample_coverage_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domSample_coverage_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "sample_coverage_enable" ); + meta->registerClass(domGl_pipeline_settings::domSample_coverage_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domSample_coverage_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domSample_coverage_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domSample_coverage_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domScissor_test_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domScissor_test_enableRef ref = new domGl_pipeline_settings::domScissor_test_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domScissor_test_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "scissor_test_enable" ); + meta->registerClass(domGl_pipeline_settings::domScissor_test_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domScissor_test_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domScissor_test_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domScissor_test_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGl_pipeline_settings::domStencil_test_enable::create(DAE& dae) +{ + domGl_pipeline_settings::domStencil_test_enableRef ref = new domGl_pipeline_settings::domStencil_test_enable(dae); + return ref; +} + + +daeMetaElement * +domGl_pipeline_settings::domStencil_test_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "stencil_test_enable" ); + meta->registerClass(domGl_pipeline_settings::domStencil_test_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_test_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGl_pipeline_settings::domStencil_test_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGl_pipeline_settings::domStencil_test_enable)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGl_sampler1D.cpp b/1.4.0/dom/src/1.4/dom/domGl_sampler1D.cpp new file mode 100644 index 0000000..51c8bac --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGl_sampler1D.cpp @@ -0,0 +1,113 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGl_sampler1D.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGl_sampler1D::create(DAE& dae) +{ + domGl_sampler1DRef ref = new domGl_sampler1D(dae); + return ref; +} + + +daeMetaElement * +domGl_sampler1D::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gl_sampler1D" ); + meta->registerClass(domGl_sampler1D::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domGl_sampler1D,elemSource) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domGl_sampler1D,elemWrap_s) ); + mea->setElementType( domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domGl_sampler1D,elemMinfilter) ); + mea->setElementType( domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domGl_sampler1D,elemMagfilter) ); + mea->setElementType( domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domGl_sampler1D,elemMipfilter) ); + mea->setElementType( domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "border_color" ); + mea->setOffset( daeOffsetOf(domGl_sampler1D,elemBorder_color) ); + mea->setElementType( domBorder_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domGl_sampler1D,elemMipmap_maxlevel) ); + mea->setElementType( domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domGl_sampler1D,elemMipmap_bias) ); + mea->setElementType( domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 8, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domGl_sampler1D,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 8 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 8 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_sampler1D)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGl_sampler2D.cpp b/1.4.0/dom/src/1.4/dom/domGl_sampler2D.cpp new file mode 100644 index 0000000..78568b1 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGl_sampler2D.cpp @@ -0,0 +1,119 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGl_sampler2D.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGl_sampler2D::create(DAE& dae) +{ + domGl_sampler2DRef ref = new domGl_sampler2D(dae); + return ref; +} + + +daeMetaElement * +domGl_sampler2D::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gl_sampler2D" ); + meta->registerClass(domGl_sampler2D::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domGl_sampler2D,elemSource) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domGl_sampler2D,elemWrap_s) ); + mea->setElementType( domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domGl_sampler2D,elemWrap_t) ); + mea->setElementType( domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domGl_sampler2D,elemMinfilter) ); + mea->setElementType( domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domGl_sampler2D,elemMagfilter) ); + mea->setElementType( domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domGl_sampler2D,elemMipfilter) ); + mea->setElementType( domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "border_color" ); + mea->setOffset( daeOffsetOf(domGl_sampler2D,elemBorder_color) ); + mea->setElementType( domBorder_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domGl_sampler2D,elemMipmap_maxlevel) ); + mea->setElementType( domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 8, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domGl_sampler2D,elemMipmap_bias) ); + mea->setElementType( domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 9, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domGl_sampler2D,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 9 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 9 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_sampler2D)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGl_sampler3D.cpp b/1.4.0/dom/src/1.4/dom/domGl_sampler3D.cpp new file mode 100644 index 0000000..e72b43e --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGl_sampler3D.cpp @@ -0,0 +1,125 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGl_sampler3D.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGl_sampler3D::create(DAE& dae) +{ + domGl_sampler3DRef ref = new domGl_sampler3D(dae); + return ref; +} + + +daeMetaElement * +domGl_sampler3D::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gl_sampler3D" ); + meta->registerClass(domGl_sampler3D::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domGl_sampler3D,elemSource) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domGl_sampler3D,elemWrap_s) ); + mea->setElementType( domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domGl_sampler3D,elemWrap_t) ); + mea->setElementType( domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "wrap_p" ); + mea->setOffset( daeOffsetOf(domGl_sampler3D,elemWrap_p) ); + mea->setElementType( domWrap_p::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domGl_sampler3D,elemMinfilter) ); + mea->setElementType( domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domGl_sampler3D,elemMagfilter) ); + mea->setElementType( domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domGl_sampler3D,elemMipfilter) ); + mea->setElementType( domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "border_color" ); + mea->setOffset( daeOffsetOf(domGl_sampler3D,elemBorder_color) ); + mea->setElementType( domBorder_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 8, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domGl_sampler3D,elemMipmap_maxlevel) ); + mea->setElementType( domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 9, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domGl_sampler3D,elemMipmap_bias) ); + mea->setElementType( domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 10, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domGl_sampler3D,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 10 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 10 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_sampler3D)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGl_samplerCUBE.cpp b/1.4.0/dom/src/1.4/dom/domGl_samplerCUBE.cpp new file mode 100644 index 0000000..dbd8cbc --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGl_samplerCUBE.cpp @@ -0,0 +1,125 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGl_samplerCUBE.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGl_samplerCUBE::create(DAE& dae) +{ + domGl_samplerCUBERef ref = new domGl_samplerCUBE(dae); + return ref; +} + + +daeMetaElement * +domGl_samplerCUBE::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gl_samplerCUBE" ); + meta->registerClass(domGl_samplerCUBE::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domGl_samplerCUBE,elemSource) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domGl_samplerCUBE,elemWrap_s) ); + mea->setElementType( domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domGl_samplerCUBE,elemWrap_t) ); + mea->setElementType( domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "wrap_p" ); + mea->setOffset( daeOffsetOf(domGl_samplerCUBE,elemWrap_p) ); + mea->setElementType( domWrap_p::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domGl_samplerCUBE,elemMinfilter) ); + mea->setElementType( domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domGl_samplerCUBE,elemMagfilter) ); + mea->setElementType( domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domGl_samplerCUBE,elemMipfilter) ); + mea->setElementType( domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "border_color" ); + mea->setOffset( daeOffsetOf(domGl_samplerCUBE,elemBorder_color) ); + mea->setElementType( domBorder_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 8, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domGl_samplerCUBE,elemMipmap_maxlevel) ); + mea->setElementType( domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 9, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domGl_samplerCUBE,elemMipmap_bias) ); + mea->setElementType( domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 10, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domGl_samplerCUBE,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 10 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 10 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_samplerCUBE)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGl_samplerDEPTH.cpp b/1.4.0/dom/src/1.4/dom/domGl_samplerDEPTH.cpp new file mode 100644 index 0000000..de61c0e --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGl_samplerDEPTH.cpp @@ -0,0 +1,95 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGl_samplerDEPTH.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGl_samplerDEPTH::create(DAE& dae) +{ + domGl_samplerDEPTHRef ref = new domGl_samplerDEPTH(dae); + return ref; +} + + +daeMetaElement * +domGl_samplerDEPTH::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gl_samplerDEPTH" ); + meta->registerClass(domGl_samplerDEPTH::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domGl_samplerDEPTH,elemSource) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domGl_samplerDEPTH,elemWrap_s) ); + mea->setElementType( domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domGl_samplerDEPTH,elemWrap_t) ); + mea->setElementType( domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domGl_samplerDEPTH,elemMinfilter) ); + mea->setElementType( domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domGl_samplerDEPTH,elemMagfilter) ); + mea->setElementType( domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 5, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domGl_samplerDEPTH,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 5 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 5 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_samplerDEPTH)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGl_samplerRECT.cpp b/1.4.0/dom/src/1.4/dom/domGl_samplerRECT.cpp new file mode 100644 index 0000000..f898fa8 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGl_samplerRECT.cpp @@ -0,0 +1,119 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGl_samplerRECT.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGl_samplerRECT::create(DAE& dae) +{ + domGl_samplerRECTRef ref = new domGl_samplerRECT(dae); + return ref; +} + + +daeMetaElement * +domGl_samplerRECT::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gl_samplerRECT" ); + meta->registerClass(domGl_samplerRECT::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domGl_samplerRECT,elemSource) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domGl_samplerRECT,elemWrap_s) ); + mea->setElementType( domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domGl_samplerRECT,elemWrap_t) ); + mea->setElementType( domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domGl_samplerRECT,elemMinfilter) ); + mea->setElementType( domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domGl_samplerRECT,elemMagfilter) ); + mea->setElementType( domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domGl_samplerRECT,elemMipfilter) ); + mea->setElementType( domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "border_color" ); + mea->setOffset( daeOffsetOf(domGl_samplerRECT,elemBorder_color) ); + mea->setElementType( domBorder_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domGl_samplerRECT,elemMipmap_maxlevel) ); + mea->setElementType( domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 8, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domGl_samplerRECT,elemMipmap_bias) ); + mea->setElementType( domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 9, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domGl_samplerRECT,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 9 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 9 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGl_samplerRECT)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGles_basic_type_common.cpp b/1.4.0/dom/src/1.4/dom/domGles_basic_type_common.cpp new file mode 100644 index 0000000..31b32c4 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGles_basic_type_common.cpp @@ -0,0 +1,1300 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGles_basic_type_common.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGles_basic_type_common::create(DAE& dae) +{ + domGles_basic_type_commonRef ref = new domGles_basic_type_common(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gles_basic_type_common" ); + meta->registerClass(domGles_basic_type_common::create); + + meta->setIsTransparent( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemBool) ); + mea->setElementType( domGles_basic_type_common::domBool::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool2" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemBool2) ); + mea->setElementType( domGles_basic_type_common::domBool2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool3" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemBool3) ); + mea->setElementType( domGles_basic_type_common::domBool3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool4" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemBool4) ); + mea->setElementType( domGles_basic_type_common::domBool4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemInt) ); + mea->setElementType( domGles_basic_type_common::domInt::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int2" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemInt2) ); + mea->setElementType( domGles_basic_type_common::domInt2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int3" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemInt3) ); + mea->setElementType( domGles_basic_type_common::domInt3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int4" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemInt4) ); + mea->setElementType( domGles_basic_type_common::domInt4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat) ); + mea->setElementType( domGles_basic_type_common::domFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat2) ); + mea->setElementType( domGles_basic_type_common::domFloat2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat3) ); + mea->setElementType( domGles_basic_type_common::domFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat4) ); + mea->setElementType( domGles_basic_type_common::domFloat4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float1x1" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat1x1) ); + mea->setElementType( domGles_basic_type_common::domFloat1x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float1x2" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat1x2) ); + mea->setElementType( domGles_basic_type_common::domFloat1x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float1x3" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat1x3) ); + mea->setElementType( domGles_basic_type_common::domFloat1x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float1x4" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat1x4) ); + mea->setElementType( domGles_basic_type_common::domFloat1x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2x1" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat2x1) ); + mea->setElementType( domGles_basic_type_common::domFloat2x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2x2" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat2x2) ); + mea->setElementType( domGles_basic_type_common::domFloat2x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2x3" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat2x3) ); + mea->setElementType( domGles_basic_type_common::domFloat2x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2x4" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat2x4) ); + mea->setElementType( domGles_basic_type_common::domFloat2x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3x1" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat3x1) ); + mea->setElementType( domGles_basic_type_common::domFloat3x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3x2" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat3x2) ); + mea->setElementType( domGles_basic_type_common::domFloat3x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3x3" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat3x3) ); + mea->setElementType( domGles_basic_type_common::domFloat3x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3x4" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat3x4) ); + mea->setElementType( domGles_basic_type_common::domFloat3x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4x1" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat4x1) ); + mea->setElementType( domGles_basic_type_common::domFloat4x1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4x2" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat4x2) ); + mea->setElementType( domGles_basic_type_common::domFloat4x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4x3" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat4x3) ); + mea->setElementType( domGles_basic_type_common::domFloat4x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4x4" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemFloat4x4) ); + mea->setElementType( domGles_basic_type_common::domFloat4x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "surface" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemSurface) ); + mea->setElementType( domFx_surface_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texture_pipeline" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemTexture_pipeline) ); + mea->setElementType( domGles_texture_pipeline::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sampler_state" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemSampler_state) ); + mea->setElementType( domGles_sampler_state::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texture_unit" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemTexture_unit) ); + mea->setElementType( domGles_texture_unit::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "enum" ); + mea->setOffset( daeOffsetOf(domGles_basic_type_common,elemEnum) ); + mea->setElementType( domGles_basic_type_common::domEnum::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGles_basic_type_common,_contents)); + meta->addContentsOrder(daeOffsetOf(domGles_basic_type_common,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGles_basic_type_common,_CMData), 1); + meta->setElementSize(sizeof(domGles_basic_type_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domBool::create(DAE& dae) +{ + domGles_basic_type_common::domBoolRef ref = new domGles_basic_type_common::domBool(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domBool::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool" ); + meta->registerClass(domGles_basic_type_common::domBool::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domBool , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domBool)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domBool2::create(DAE& dae) +{ + domGles_basic_type_common::domBool2Ref ref = new domGles_basic_type_common::domBool2(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domBool2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool2" ); + meta->registerClass(domGles_basic_type_common::domBool2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool2")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domBool2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domBool2)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domBool3::create(DAE& dae) +{ + domGles_basic_type_common::domBool3Ref ref = new domGles_basic_type_common::domBool3(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domBool3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool3" ); + meta->registerClass(domGles_basic_type_common::domBool3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool3")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domBool3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domBool3)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domBool4::create(DAE& dae) +{ + domGles_basic_type_common::domBool4Ref ref = new domGles_basic_type_common::domBool4(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domBool4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool4" ); + meta->registerClass(domGles_basic_type_common::domBool4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool4")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domBool4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domBool4)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domInt::create(DAE& dae) +{ + domGles_basic_type_common::domIntRef ref = new domGles_basic_type_common::domInt(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domInt::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int" ); + meta->registerClass(domGles_basic_type_common::domInt::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Int")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domInt , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domInt)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domInt2::create(DAE& dae) +{ + domGles_basic_type_common::domInt2Ref ref = new domGles_basic_type_common::domInt2(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domInt2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int2" ); + meta->registerClass(domGles_basic_type_common::domInt2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Int2")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domInt2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domInt2)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domInt3::create(DAE& dae) +{ + domGles_basic_type_common::domInt3Ref ref = new domGles_basic_type_common::domInt3(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domInt3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int3" ); + meta->registerClass(domGles_basic_type_common::domInt3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Int3")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domInt3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domInt3)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domInt4::create(DAE& dae) +{ + domGles_basic_type_common::domInt4Ref ref = new domGles_basic_type_common::domInt4(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domInt4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int4" ); + meta->registerClass(domGles_basic_type_common::domInt4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Int4")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domInt4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domInt4)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat::create(DAE& dae) +{ + domGles_basic_type_common::domFloatRef ref = new domGles_basic_type_common::domFloat(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float" ); + meta->registerClass(domGles_basic_type_common::domFloat::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat2::create(DAE& dae) +{ + domGles_basic_type_common::domFloat2Ref ref = new domGles_basic_type_common::domFloat2(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2" ); + meta->registerClass(domGles_basic_type_common::domFloat2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat2)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat3::create(DAE& dae) +{ + domGles_basic_type_common::domFloat3Ref ref = new domGles_basic_type_common::domFloat3(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3" ); + meta->registerClass(domGles_basic_type_common::domFloat3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat3)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat4::create(DAE& dae) +{ + domGles_basic_type_common::domFloat4Ref ref = new domGles_basic_type_common::domFloat4(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4" ); + meta->registerClass(domGles_basic_type_common::domFloat4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat4)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat1x1::create(DAE& dae) +{ + domGles_basic_type_common::domFloat1x1Ref ref = new domGles_basic_type_common::domFloat1x1(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat1x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float1x1" ); + meta->registerClass(domGles_basic_type_common::domFloat1x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat1x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat1x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat1x2::create(DAE& dae) +{ + domGles_basic_type_common::domFloat1x2Ref ref = new domGles_basic_type_common::domFloat1x2(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat1x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float1x2" ); + meta->registerClass(domGles_basic_type_common::domFloat1x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat1x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat1x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat1x3::create(DAE& dae) +{ + domGles_basic_type_common::domFloat1x3Ref ref = new domGles_basic_type_common::domFloat1x3(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat1x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float1x3" ); + meta->registerClass(domGles_basic_type_common::domFloat1x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat1x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat1x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat1x4::create(DAE& dae) +{ + domGles_basic_type_common::domFloat1x4Ref ref = new domGles_basic_type_common::domFloat1x4(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat1x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float1x4" ); + meta->registerClass(domGles_basic_type_common::domFloat1x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat1x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat1x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat2x1::create(DAE& dae) +{ + domGles_basic_type_common::domFloat2x1Ref ref = new domGles_basic_type_common::domFloat2x1(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat2x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2x1" ); + meta->registerClass(domGles_basic_type_common::domFloat2x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat2x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat2x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat2x2::create(DAE& dae) +{ + domGles_basic_type_common::domFloat2x2Ref ref = new domGles_basic_type_common::domFloat2x2(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat2x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2x2" ); + meta->registerClass(domGles_basic_type_common::domFloat2x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2x2")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat2x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat2x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat2x3::create(DAE& dae) +{ + domGles_basic_type_common::domFloat2x3Ref ref = new domGles_basic_type_common::domFloat2x3(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat2x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2x3" ); + meta->registerClass(domGles_basic_type_common::domFloat2x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2x3")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat2x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat2x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat2x4::create(DAE& dae) +{ + domGles_basic_type_common::domFloat2x4Ref ref = new domGles_basic_type_common::domFloat2x4(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat2x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2x4" ); + meta->registerClass(domGles_basic_type_common::domFloat2x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2x4")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat2x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat2x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat3x1::create(DAE& dae) +{ + domGles_basic_type_common::domFloat3x1Ref ref = new domGles_basic_type_common::domFloat3x1(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat3x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3x1" ); + meta->registerClass(domGles_basic_type_common::domFloat3x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat3x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat3x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat3x2::create(DAE& dae) +{ + domGles_basic_type_common::domFloat3x2Ref ref = new domGles_basic_type_common::domFloat3x2(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat3x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3x2" ); + meta->registerClass(domGles_basic_type_common::domFloat3x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3x2")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat3x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat3x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat3x3::create(DAE& dae) +{ + domGles_basic_type_common::domFloat3x3Ref ref = new domGles_basic_type_common::domFloat3x3(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat3x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3x3" ); + meta->registerClass(domGles_basic_type_common::domFloat3x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3x3")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat3x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat3x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat3x4::create(DAE& dae) +{ + domGles_basic_type_common::domFloat3x4Ref ref = new domGles_basic_type_common::domFloat3x4(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat3x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3x4" ); + meta->registerClass(domGles_basic_type_common::domFloat3x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3x4")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat3x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat3x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat4x1::create(DAE& dae) +{ + domGles_basic_type_common::domFloat4x1Ref ref = new domGles_basic_type_common::domFloat4x1(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat4x1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4x1" ); + meta->registerClass(domGles_basic_type_common::domFloat4x1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat4x1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat4x1)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat4x2::create(DAE& dae) +{ + domGles_basic_type_common::domFloat4x2Ref ref = new domGles_basic_type_common::domFloat4x2(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat4x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4x2" ); + meta->registerClass(domGles_basic_type_common::domFloat4x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4x2")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat4x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat4x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat4x3::create(DAE& dae) +{ + domGles_basic_type_common::domFloat4x3Ref ref = new domGles_basic_type_common::domFloat4x3(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat4x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4x3" ); + meta->registerClass(domGles_basic_type_common::domFloat4x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4x3")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat4x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat4x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domFloat4x4::create(DAE& dae) +{ + domGles_basic_type_common::domFloat4x4Ref ref = new domGles_basic_type_common::domFloat4x4(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domFloat4x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4x4" ); + meta->registerClass(domGles_basic_type_common::domFloat4x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4x4")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domFloat4x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domFloat4x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_basic_type_common::domEnum::create(DAE& dae) +{ + domGles_basic_type_common::domEnumRef ref = new domGles_basic_type_common::domEnum(dae); + return ref; +} + + +daeMetaElement * +domGles_basic_type_common::domEnum::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "enum" ); + meta->registerClass(domGles_basic_type_common::domEnum::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Gles_enumeration")); + ma->setOffset( daeOffsetOf( domGles_basic_type_common::domEnum , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_basic_type_common::domEnum)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGles_newparam.cpp b/1.4.0/dom/src/1.4/dom/domGles_newparam.cpp new file mode 100644 index 0000000..b317e47 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGles_newparam.cpp @@ -0,0 +1,161 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGles_newparam.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGles_newparam::create(DAE& dae) +{ + domGles_newparamRef ref = new domGles_newparam(dae); + return ref; +} + + +daeMetaElement * +domGles_newparam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gles_newparam" ); + meta->registerClass(domGles_newparam::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domGles_newparam,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "semantic" ); + mea->setOffset( daeOffsetOf(domGles_newparam,elemSemantic) ); + mea->setElementType( domGles_newparam::domSemantic::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "modifier" ); + mea->setOffset( daeOffsetOf(domGles_newparam,elemModifier) ); + mea->setElementType( domGles_newparam::domModifier::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 1, 1 ); + mea->setName( "gles_basic_type_common" ); + mea->setOffset( daeOffsetOf(domGles_newparam,elemGles_basic_type_common) ); + mea->setElementType( domGles_basic_type_common::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 3, 1, 1 ) ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_newparam , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_newparam)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_newparam::domSemantic::create(DAE& dae) +{ + domGles_newparam::domSemanticRef ref = new domGles_newparam::domSemantic(dae); + return ref; +} + + +daeMetaElement * +domGles_newparam::domSemantic::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "semantic" ); + meta->registerClass(domGles_newparam::domSemantic::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_newparam::domSemantic , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_newparam::domSemantic)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_newparam::domModifier::create(DAE& dae) +{ + domGles_newparam::domModifierRef ref = new domGles_newparam::domModifier(dae); + return ref; +} + + +daeMetaElement * +domGles_newparam::domModifier::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "modifier" ); + meta->registerClass(domGles_newparam::domModifier::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_modifier_enum_common")); + ma->setOffset( daeOffsetOf( domGles_newparam::domModifier , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_newparam::domModifier)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGles_pipeline_settings.cpp b/1.4.0/dom/src/1.4/dom/domGles_pipeline_settings.cpp new file mode 100644 index 0000000..60a6eb0 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGles_pipeline_settings.cpp @@ -0,0 +1,4944 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGles_pipeline_settings.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGles_pipeline_settings::create(DAE& dae) +{ + domGles_pipeline_settingsRef ref = new domGles_pipeline_settings(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gles_pipeline_settings" ); + meta->registerClass(domGles_pipeline_settings::create); + + meta->setIsTransparent( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "alpha_func" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemAlpha_func) ); + mea->setElementType( domGles_pipeline_settings::domAlpha_func::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "blend_func" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemBlend_func) ); + mea->setElementType( domGles_pipeline_settings::domBlend_func::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "clear_color" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemClear_color) ); + mea->setElementType( domGles_pipeline_settings::domClear_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "clear_stencil" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemClear_stencil) ); + mea->setElementType( domGles_pipeline_settings::domClear_stencil::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "clear_depth" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemClear_depth) ); + mea->setElementType( domGles_pipeline_settings::domClear_depth::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "clip_plane" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemClip_plane) ); + mea->setElementType( domGles_pipeline_settings::domClip_plane::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "color_mask" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemColor_mask) ); + mea->setElementType( domGles_pipeline_settings::domColor_mask::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "cull_face" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemCull_face) ); + mea->setElementType( domGles_pipeline_settings::domCull_face::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "depth_func" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemDepth_func) ); + mea->setElementType( domGles_pipeline_settings::domDepth_func::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "depth_mask" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemDepth_mask) ); + mea->setElementType( domGles_pipeline_settings::domDepth_mask::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "depth_range" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemDepth_range) ); + mea->setElementType( domGles_pipeline_settings::domDepth_range::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fog_color" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemFog_color) ); + mea->setElementType( domGles_pipeline_settings::domFog_color::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fog_density" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemFog_density) ); + mea->setElementType( domGles_pipeline_settings::domFog_density::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fog_mode" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemFog_mode) ); + mea->setElementType( domGles_pipeline_settings::domFog_mode::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fog_start" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemFog_start) ); + mea->setElementType( domGles_pipeline_settings::domFog_start::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fog_end" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemFog_end) ); + mea->setElementType( domGles_pipeline_settings::domFog_end::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "front_face" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemFront_face) ); + mea->setElementType( domGles_pipeline_settings::domFront_face::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texture_pipeline" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemTexture_pipeline) ); + mea->setElementType( domGles_pipeline_settings::domTexture_pipeline::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "logic_op" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLogic_op) ); + mea->setElementType( domGles_pipeline_settings::domLogic_op::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_ambient" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLight_ambient) ); + mea->setElementType( domGles_pipeline_settings::domLight_ambient::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_diffuse" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLight_diffuse) ); + mea->setElementType( domGles_pipeline_settings::domLight_diffuse::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_specular" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLight_specular) ); + mea->setElementType( domGles_pipeline_settings::domLight_specular::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_position" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLight_position) ); + mea->setElementType( domGles_pipeline_settings::domLight_position::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_constant_attenuation" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLight_constant_attenuation) ); + mea->setElementType( domGles_pipeline_settings::domLight_constant_attenuation::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_linear_attenutation" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLight_linear_attenutation) ); + mea->setElementType( domGles_pipeline_settings::domLight_linear_attenutation::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_quadratic_attenuation" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLight_quadratic_attenuation) ); + mea->setElementType( domGles_pipeline_settings::domLight_quadratic_attenuation::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_spot_cutoff" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLight_spot_cutoff) ); + mea->setElementType( domGles_pipeline_settings::domLight_spot_cutoff::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_spot_direction" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLight_spot_direction) ); + mea->setElementType( domGles_pipeline_settings::domLight_spot_direction::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_spot_exponent" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLight_spot_exponent) ); + mea->setElementType( domGles_pipeline_settings::domLight_spot_exponent::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_model_ambient" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLight_model_ambient) ); + mea->setElementType( domGles_pipeline_settings::domLight_model_ambient::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "line_width" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLine_width) ); + mea->setElementType( domGles_pipeline_settings::domLine_width::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "material_ambient" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemMaterial_ambient) ); + mea->setElementType( domGles_pipeline_settings::domMaterial_ambient::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "material_diffuse" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemMaterial_diffuse) ); + mea->setElementType( domGles_pipeline_settings::domMaterial_diffuse::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "material_emission" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemMaterial_emission) ); + mea->setElementType( domGles_pipeline_settings::domMaterial_emission::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "material_shininess" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemMaterial_shininess) ); + mea->setElementType( domGles_pipeline_settings::domMaterial_shininess::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "material_specular" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemMaterial_specular) ); + mea->setElementType( domGles_pipeline_settings::domMaterial_specular::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "model_view_matrix" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemModel_view_matrix) ); + mea->setElementType( domGles_pipeline_settings::domModel_view_matrix::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "point_distance_attenuation" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemPoint_distance_attenuation) ); + mea->setElementType( domGles_pipeline_settings::domPoint_distance_attenuation::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "point_fade_threshold_size" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemPoint_fade_threshold_size) ); + mea->setElementType( domGles_pipeline_settings::domPoint_fade_threshold_size::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "point_size" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemPoint_size) ); + mea->setElementType( domGles_pipeline_settings::domPoint_size::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "point_size_min" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemPoint_size_min) ); + mea->setElementType( domGles_pipeline_settings::domPoint_size_min::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "point_size_max" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemPoint_size_max) ); + mea->setElementType( domGles_pipeline_settings::domPoint_size_max::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "polygon_offset" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemPolygon_offset) ); + mea->setElementType( domGles_pipeline_settings::domPolygon_offset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "projection_matrix" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemProjection_matrix) ); + mea->setElementType( domGles_pipeline_settings::domProjection_matrix::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "scissor" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemScissor) ); + mea->setElementType( domGles_pipeline_settings::domScissor::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "shade_model" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemShade_model) ); + mea->setElementType( domGles_pipeline_settings::domShade_model::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "stencil_func" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemStencil_func) ); + mea->setElementType( domGles_pipeline_settings::domStencil_func::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "stencil_mask" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemStencil_mask) ); + mea->setElementType( domGles_pipeline_settings::domStencil_mask::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "stencil_op" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemStencil_op) ); + mea->setElementType( domGles_pipeline_settings::domStencil_op::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "alpha_test_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemAlpha_test_enable) ); + mea->setElementType( domGles_pipeline_settings::domAlpha_test_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "blend_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemBlend_enable) ); + mea->setElementType( domGles_pipeline_settings::domBlend_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "clip_plane_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemClip_plane_enable) ); + mea->setElementType( domGles_pipeline_settings::domClip_plane_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "color_logic_op_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemColor_logic_op_enable) ); + mea->setElementType( domGles_pipeline_settings::domColor_logic_op_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "color_material_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemColor_material_enable) ); + mea->setElementType( domGles_pipeline_settings::domColor_material_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "cull_face_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemCull_face_enable) ); + mea->setElementType( domGles_pipeline_settings::domCull_face_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "depth_test_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemDepth_test_enable) ); + mea->setElementType( domGles_pipeline_settings::domDepth_test_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "dither_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemDither_enable) ); + mea->setElementType( domGles_pipeline_settings::domDither_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fog_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemFog_enable) ); + mea->setElementType( domGles_pipeline_settings::domFog_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texture_pipeline_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemTexture_pipeline_enable) ); + mea->setElementType( domGles_pipeline_settings::domTexture_pipeline_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLight_enable) ); + mea->setElementType( domGles_pipeline_settings::domLight_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "lighting_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLighting_enable) ); + mea->setElementType( domGles_pipeline_settings::domLighting_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "light_model_two_side_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLight_model_two_side_enable) ); + mea->setElementType( domGles_pipeline_settings::domLight_model_two_side_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "line_smooth_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemLine_smooth_enable) ); + mea->setElementType( domGles_pipeline_settings::domLine_smooth_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "multisample_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemMultisample_enable) ); + mea->setElementType( domGles_pipeline_settings::domMultisample_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "normalize_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemNormalize_enable) ); + mea->setElementType( domGles_pipeline_settings::domNormalize_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "point_smooth_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemPoint_smooth_enable) ); + mea->setElementType( domGles_pipeline_settings::domPoint_smooth_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "polygon_offset_fill_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemPolygon_offset_fill_enable) ); + mea->setElementType( domGles_pipeline_settings::domPolygon_offset_fill_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "rescale_normal_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemRescale_normal_enable) ); + mea->setElementType( domGles_pipeline_settings::domRescale_normal_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sample_alpha_to_coverage_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemSample_alpha_to_coverage_enable) ); + mea->setElementType( domGles_pipeline_settings::domSample_alpha_to_coverage_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sample_alpha_to_one_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemSample_alpha_to_one_enable) ); + mea->setElementType( domGles_pipeline_settings::domSample_alpha_to_one_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sample_coverage_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemSample_coverage_enable) ); + mea->setElementType( domGles_pipeline_settings::domSample_coverage_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "scissor_test_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemScissor_test_enable) ); + mea->setElementType( domGles_pipeline_settings::domScissor_test_enable::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "stencil_test_enable" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings,elemStencil_test_enable) ); + mea->setElementType( domGles_pipeline_settings::domStencil_test_enable::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGles_pipeline_settings,_contents)); + meta->addContentsOrder(daeOffsetOf(domGles_pipeline_settings,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGles_pipeline_settings,_CMData), 1); + meta->setElementSize(sizeof(domGles_pipeline_settings)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domAlpha_func::create(DAE& dae) +{ + domGles_pipeline_settings::domAlpha_funcRef ref = new domGles_pipeline_settings::domAlpha_func(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domAlpha_func::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "alpha_func" ); + meta->registerClass(domGles_pipeline_settings::domAlpha_func::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "func" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings::domAlpha_func,elemFunc) ); + mea->setElementType( domGles_pipeline_settings::domAlpha_func::domFunc::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "value" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings::domAlpha_func,elemValue) ); + mea->setElementType( domGles_pipeline_settings::domAlpha_func::domValue::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGles_pipeline_settings::domAlpha_func)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domAlpha_func::domFunc::create(DAE& dae) +{ + domGles_pipeline_settings::domAlpha_func::domFuncRef ref = new domGles_pipeline_settings::domAlpha_func::domFunc(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domAlpha_func::domFunc::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "func" ); + meta->registerClass(domGles_pipeline_settings::domAlpha_func::domFunc::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_func_type")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domAlpha_func::domFunc , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ALWAYS"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domAlpha_func::domFunc , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domAlpha_func::domFunc)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domAlpha_func::domValue::create(DAE& dae) +{ + domGles_pipeline_settings::domAlpha_func::domValueRef ref = new domGles_pipeline_settings::domAlpha_func::domValue(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domAlpha_func::domValue::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "value" ); + meta->registerClass(domGles_pipeline_settings::domAlpha_func::domValue::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_alpha_value_type")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domAlpha_func::domValue , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0.0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domAlpha_func::domValue , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domAlpha_func::domValue)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domBlend_func::create(DAE& dae) +{ + domGles_pipeline_settings::domBlend_funcRef ref = new domGles_pipeline_settings::domBlend_func(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domBlend_func::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "blend_func" ); + meta->registerClass(domGles_pipeline_settings::domBlend_func::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "src" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings::domBlend_func,elemSrc) ); + mea->setElementType( domGles_pipeline_settings::domBlend_func::domSrc::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "dest" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings::domBlend_func,elemDest) ); + mea->setElementType( domGles_pipeline_settings::domBlend_func::domDest::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGles_pipeline_settings::domBlend_func)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domBlend_func::domSrc::create(DAE& dae) +{ + domGles_pipeline_settings::domBlend_func::domSrcRef ref = new domGles_pipeline_settings::domBlend_func::domSrc(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domBlend_func::domSrc::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "src" ); + meta->registerClass(domGles_pipeline_settings::domBlend_func::domSrc::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_blend_type")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domBlend_func::domSrc , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ONE"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domBlend_func::domSrc , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domBlend_func::domSrc)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domBlend_func::domDest::create(DAE& dae) +{ + domGles_pipeline_settings::domBlend_func::domDestRef ref = new domGles_pipeline_settings::domBlend_func::domDest(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domBlend_func::domDest::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "dest" ); + meta->registerClass(domGles_pipeline_settings::domBlend_func::domDest::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_blend_type")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domBlend_func::domDest , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ZERO"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domBlend_func::domDest , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domBlend_func::domDest)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domClear_color::create(DAE& dae) +{ + domGles_pipeline_settings::domClear_colorRef ref = new domGles_pipeline_settings::domClear_color(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domClear_color::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "clear_color" ); + meta->registerClass(domGles_pipeline_settings::domClear_color::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domClear_color , attrValue )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domClear_color , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domClear_color)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domClear_stencil::create(DAE& dae) +{ + domGles_pipeline_settings::domClear_stencilRef ref = new domGles_pipeline_settings::domClear_stencil(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domClear_stencil::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "clear_stencil" ); + meta->registerClass(domGles_pipeline_settings::domClear_stencil::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Int")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domClear_stencil , attrValue )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domClear_stencil , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domClear_stencil)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domClear_depth::create(DAE& dae) +{ + domGles_pipeline_settings::domClear_depthRef ref = new domGles_pipeline_settings::domClear_depth(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domClear_depth::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "clear_depth" ); + meta->registerClass(domGles_pipeline_settings::domClear_depth::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domClear_depth , attrValue )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domClear_depth , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domClear_depth)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domClip_plane::create(DAE& dae) +{ + domGles_pipeline_settings::domClip_planeRef ref = new domGles_pipeline_settings::domClip_plane(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domClip_plane::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "clip_plane" ); + meta->registerClass(domGles_pipeline_settings::domClip_plane::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domClip_plane , attrValue )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domClip_plane , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GLES_MAX_CLIP_PLANES_index")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domClip_plane , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domClip_plane)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domColor_mask::create(DAE& dae) +{ + domGles_pipeline_settings::domColor_maskRef ref = new domGles_pipeline_settings::domColor_mask(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domColor_mask::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "color_mask" ); + meta->registerClass(domGles_pipeline_settings::domColor_mask::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domColor_mask , attrValue )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domColor_mask , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domColor_mask)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domCull_face::create(DAE& dae) +{ + domGles_pipeline_settings::domCull_faceRef ref = new domGles_pipeline_settings::domCull_face(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domCull_face::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cull_face" ); + meta->registerClass(domGles_pipeline_settings::domCull_face::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_face_type")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domCull_face , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "BACK"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domCull_face , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domCull_face)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domDepth_func::create(DAE& dae) +{ + domGles_pipeline_settings::domDepth_funcRef ref = new domGles_pipeline_settings::domDepth_func(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domDepth_func::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "depth_func" ); + meta->registerClass(domGles_pipeline_settings::domDepth_func::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_func_type")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domDepth_func , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ALWAYS"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domDepth_func , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domDepth_func)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domDepth_mask::create(DAE& dae) +{ + domGles_pipeline_settings::domDepth_maskRef ref = new domGles_pipeline_settings::domDepth_mask(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domDepth_mask::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "depth_mask" ); + meta->registerClass(domGles_pipeline_settings::domDepth_mask::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domDepth_mask , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domDepth_mask , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domDepth_mask)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domDepth_range::create(DAE& dae) +{ + domGles_pipeline_settings::domDepth_rangeRef ref = new domGles_pipeline_settings::domDepth_range(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domDepth_range::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "depth_range" ); + meta->registerClass(domGles_pipeline_settings::domDepth_range::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domDepth_range , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domDepth_range , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domDepth_range)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domFog_color::create(DAE& dae) +{ + domGles_pipeline_settings::domFog_colorRef ref = new domGles_pipeline_settings::domFog_color(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domFog_color::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fog_color" ); + meta->registerClass(domGles_pipeline_settings::domFog_color::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domFog_color , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 0 0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domFog_color , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domFog_color)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domFog_density::create(DAE& dae) +{ + domGles_pipeline_settings::domFog_densityRef ref = new domGles_pipeline_settings::domFog_density(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domFog_density::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fog_density" ); + meta->registerClass(domGles_pipeline_settings::domFog_density::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domFog_density , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domFog_density , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domFog_density)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domFog_mode::create(DAE& dae) +{ + domGles_pipeline_settings::domFog_modeRef ref = new domGles_pipeline_settings::domFog_mode(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domFog_mode::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fog_mode" ); + meta->registerClass(domGles_pipeline_settings::domFog_mode::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_fog_type")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domFog_mode , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "EXP"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domFog_mode , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domFog_mode)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domFog_start::create(DAE& dae) +{ + domGles_pipeline_settings::domFog_startRef ref = new domGles_pipeline_settings::domFog_start(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domFog_start::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fog_start" ); + meta->registerClass(domGles_pipeline_settings::domFog_start::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domFog_start , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domFog_start , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domFog_start)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domFog_end::create(DAE& dae) +{ + domGles_pipeline_settings::domFog_endRef ref = new domGles_pipeline_settings::domFog_end(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domFog_end::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fog_end" ); + meta->registerClass(domGles_pipeline_settings::domFog_end::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domFog_end , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domFog_end , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domFog_end)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domFront_face::create(DAE& dae) +{ + domGles_pipeline_settings::domFront_faceRef ref = new domGles_pipeline_settings::domFront_face(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domFront_face::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "front_face" ); + meta->registerClass(domGles_pipeline_settings::domFront_face::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_front_face_type")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domFront_face , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "CCW"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domFront_face , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domFront_face)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domTexture_pipeline::create(DAE& dae) +{ + domGles_pipeline_settings::domTexture_pipelineRef ref = new domGles_pipeline_settings::domTexture_pipeline(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domTexture_pipeline::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "texture_pipeline" ); + meta->registerClass(domGles_pipeline_settings::domTexture_pipeline::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "value" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings::domTexture_pipeline,elemValue) ); + mea->setElementType( domGles_texture_pipeline::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domTexture_pipeline , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domTexture_pipeline)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLogic_op::create(DAE& dae) +{ + domGles_pipeline_settings::domLogic_opRef ref = new domGles_pipeline_settings::domLogic_op(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLogic_op::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "logic_op" ); + meta->registerClass(domGles_pipeline_settings::domLogic_op::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_logic_op_type")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLogic_op , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "COPY"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLogic_op , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLogic_op)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLight_ambient::create(DAE& dae) +{ + domGles_pipeline_settings::domLight_ambientRef ref = new domGles_pipeline_settings::domLight_ambient(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLight_ambient::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_ambient" ); + meta->registerClass(domGles_pipeline_settings::domLight_ambient::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_ambient , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 0 1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_ambient , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GLES_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_ambient , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLight_ambient)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLight_diffuse::create(DAE& dae) +{ + domGles_pipeline_settings::domLight_diffuseRef ref = new domGles_pipeline_settings::domLight_diffuse(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLight_diffuse::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_diffuse" ); + meta->registerClass(domGles_pipeline_settings::domLight_diffuse::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_diffuse , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 0 0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_diffuse , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GLES_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_diffuse , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLight_diffuse)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLight_specular::create(DAE& dae) +{ + domGles_pipeline_settings::domLight_specularRef ref = new domGles_pipeline_settings::domLight_specular(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLight_specular::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_specular" ); + meta->registerClass(domGles_pipeline_settings::domLight_specular::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_specular , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 0 0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_specular , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GLES_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_specular , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLight_specular)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLight_position::create(DAE& dae) +{ + domGles_pipeline_settings::domLight_positionRef ref = new domGles_pipeline_settings::domLight_position(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLight_position::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_position" ); + meta->registerClass(domGles_pipeline_settings::domLight_position::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_position , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 1 0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_position , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GLES_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_position , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLight_position)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLight_constant_attenuation::create(DAE& dae) +{ + domGles_pipeline_settings::domLight_constant_attenuationRef ref = new domGles_pipeline_settings::domLight_constant_attenuation(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLight_constant_attenuation::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_constant_attenuation" ); + meta->registerClass(domGles_pipeline_settings::domLight_constant_attenuation::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_constant_attenuation , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_constant_attenuation , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GLES_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_constant_attenuation , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLight_constant_attenuation)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLight_linear_attenutation::create(DAE& dae) +{ + domGles_pipeline_settings::domLight_linear_attenutationRef ref = new domGles_pipeline_settings::domLight_linear_attenutation(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLight_linear_attenutation::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_linear_attenutation" ); + meta->registerClass(domGles_pipeline_settings::domLight_linear_attenutation::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_linear_attenutation , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_linear_attenutation , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GLES_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_linear_attenutation , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLight_linear_attenutation)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLight_quadratic_attenuation::create(DAE& dae) +{ + domGles_pipeline_settings::domLight_quadratic_attenuationRef ref = new domGles_pipeline_settings::domLight_quadratic_attenuation(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLight_quadratic_attenuation::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_quadratic_attenuation" ); + meta->registerClass(domGles_pipeline_settings::domLight_quadratic_attenuation::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_quadratic_attenuation , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_quadratic_attenuation , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GLES_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_quadratic_attenuation , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLight_quadratic_attenuation)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLight_spot_cutoff::create(DAE& dae) +{ + domGles_pipeline_settings::domLight_spot_cutoffRef ref = new domGles_pipeline_settings::domLight_spot_cutoff(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLight_spot_cutoff::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_spot_cutoff" ); + meta->registerClass(domGles_pipeline_settings::domLight_spot_cutoff::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_spot_cutoff , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "180"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_spot_cutoff , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GLES_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_spot_cutoff , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLight_spot_cutoff)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLight_spot_direction::create(DAE& dae) +{ + domGles_pipeline_settings::domLight_spot_directionRef ref = new domGles_pipeline_settings::domLight_spot_direction(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLight_spot_direction::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_spot_direction" ); + meta->registerClass(domGles_pipeline_settings::domLight_spot_direction::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_spot_direction , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 -1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_spot_direction , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GLES_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_spot_direction , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLight_spot_direction)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLight_spot_exponent::create(DAE& dae) +{ + domGles_pipeline_settings::domLight_spot_exponentRef ref = new domGles_pipeline_settings::domLight_spot_exponent(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLight_spot_exponent::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_spot_exponent" ); + meta->registerClass(domGles_pipeline_settings::domLight_spot_exponent::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_spot_exponent , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_spot_exponent , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GLES_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_spot_exponent , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLight_spot_exponent)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLight_model_ambient::create(DAE& dae) +{ + domGles_pipeline_settings::domLight_model_ambientRef ref = new domGles_pipeline_settings::domLight_model_ambient(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLight_model_ambient::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_model_ambient" ); + meta->registerClass(domGles_pipeline_settings::domLight_model_ambient::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_model_ambient , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0.2 0.2 0.2 1.0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_model_ambient , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLight_model_ambient)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLine_width::create(DAE& dae) +{ + domGles_pipeline_settings::domLine_widthRef ref = new domGles_pipeline_settings::domLine_width(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLine_width::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "line_width" ); + meta->registerClass(domGles_pipeline_settings::domLine_width::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLine_width , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLine_width , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLine_width)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domMaterial_ambient::create(DAE& dae) +{ + domGles_pipeline_settings::domMaterial_ambientRef ref = new domGles_pipeline_settings::domMaterial_ambient(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domMaterial_ambient::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "material_ambient" ); + meta->registerClass(domGles_pipeline_settings::domMaterial_ambient::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domMaterial_ambient , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0.2 0.2 0.2 1.0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domMaterial_ambient , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domMaterial_ambient)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domMaterial_diffuse::create(DAE& dae) +{ + domGles_pipeline_settings::domMaterial_diffuseRef ref = new domGles_pipeline_settings::domMaterial_diffuse(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domMaterial_diffuse::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "material_diffuse" ); + meta->registerClass(domGles_pipeline_settings::domMaterial_diffuse::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domMaterial_diffuse , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0.8 0.8 0.8 1.0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domMaterial_diffuse , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domMaterial_diffuse)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domMaterial_emission::create(DAE& dae) +{ + domGles_pipeline_settings::domMaterial_emissionRef ref = new domGles_pipeline_settings::domMaterial_emission(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domMaterial_emission::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "material_emission" ); + meta->registerClass(domGles_pipeline_settings::domMaterial_emission::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domMaterial_emission , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 0 1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domMaterial_emission , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domMaterial_emission)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domMaterial_shininess::create(DAE& dae) +{ + domGles_pipeline_settings::domMaterial_shininessRef ref = new domGles_pipeline_settings::domMaterial_shininess(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domMaterial_shininess::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "material_shininess" ); + meta->registerClass(domGles_pipeline_settings::domMaterial_shininess::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domMaterial_shininess , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domMaterial_shininess , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domMaterial_shininess)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domMaterial_specular::create(DAE& dae) +{ + domGles_pipeline_settings::domMaterial_specularRef ref = new domGles_pipeline_settings::domMaterial_specular(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domMaterial_specular::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "material_specular" ); + meta->registerClass(domGles_pipeline_settings::domMaterial_specular::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domMaterial_specular , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0 0 1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domMaterial_specular , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domMaterial_specular)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domModel_view_matrix::create(DAE& dae) +{ + domGles_pipeline_settings::domModel_view_matrixRef ref = new domGles_pipeline_settings::domModel_view_matrix(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domModel_view_matrix::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "model_view_matrix" ); + meta->registerClass(domGles_pipeline_settings::domModel_view_matrix::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4x4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domModel_view_matrix , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domModel_view_matrix , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domModel_view_matrix)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domPoint_distance_attenuation::create(DAE& dae) +{ + domGles_pipeline_settings::domPoint_distance_attenuationRef ref = new domGles_pipeline_settings::domPoint_distance_attenuation(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domPoint_distance_attenuation::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "point_distance_attenuation" ); + meta->registerClass(domGles_pipeline_settings::domPoint_distance_attenuation::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPoint_distance_attenuation , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1 0 0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPoint_distance_attenuation , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domPoint_distance_attenuation)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domPoint_fade_threshold_size::create(DAE& dae) +{ + domGles_pipeline_settings::domPoint_fade_threshold_sizeRef ref = new domGles_pipeline_settings::domPoint_fade_threshold_size(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domPoint_fade_threshold_size::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "point_fade_threshold_size" ); + meta->registerClass(domGles_pipeline_settings::domPoint_fade_threshold_size::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPoint_fade_threshold_size , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPoint_fade_threshold_size , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domPoint_fade_threshold_size)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domPoint_size::create(DAE& dae) +{ + domGles_pipeline_settings::domPoint_sizeRef ref = new domGles_pipeline_settings::domPoint_size(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domPoint_size::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "point_size" ); + meta->registerClass(domGles_pipeline_settings::domPoint_size::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPoint_size , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPoint_size , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domPoint_size)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domPoint_size_min::create(DAE& dae) +{ + domGles_pipeline_settings::domPoint_size_minRef ref = new domGles_pipeline_settings::domPoint_size_min(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domPoint_size_min::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "point_size_min" ); + meta->registerClass(domGles_pipeline_settings::domPoint_size_min::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPoint_size_min , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPoint_size_min , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domPoint_size_min)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domPoint_size_max::create(DAE& dae) +{ + domGles_pipeline_settings::domPoint_size_maxRef ref = new domGles_pipeline_settings::domPoint_size_max(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domPoint_size_max::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "point_size_max" ); + meta->registerClass(domGles_pipeline_settings::domPoint_size_max::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPoint_size_max , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPoint_size_max , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domPoint_size_max)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domPolygon_offset::create(DAE& dae) +{ + domGles_pipeline_settings::domPolygon_offsetRef ref = new domGles_pipeline_settings::domPolygon_offset(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domPolygon_offset::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "polygon_offset" ); + meta->registerClass(domGles_pipeline_settings::domPolygon_offset::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPolygon_offset , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0 0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPolygon_offset , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domPolygon_offset)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domProjection_matrix::create(DAE& dae) +{ + domGles_pipeline_settings::domProjection_matrixRef ref = new domGles_pipeline_settings::domProjection_matrix(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domProjection_matrix::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "projection_matrix" ); + meta->registerClass(domGles_pipeline_settings::domProjection_matrix::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4x4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domProjection_matrix , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domProjection_matrix , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domProjection_matrix)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domScissor::create(DAE& dae) +{ + domGles_pipeline_settings::domScissorRef ref = new domGles_pipeline_settings::domScissor(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domScissor::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "scissor" ); + meta->registerClass(domGles_pipeline_settings::domScissor::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Int4")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domScissor , attrValue )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domScissor , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domScissor)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domShade_model::create(DAE& dae) +{ + domGles_pipeline_settings::domShade_modelRef ref = new domGles_pipeline_settings::domShade_model(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domShade_model::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "shade_model" ); + meta->registerClass(domGles_pipeline_settings::domShade_model::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_shade_model_type")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domShade_model , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "SMOOTH"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domShade_model , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domShade_model)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domStencil_func::create(DAE& dae) +{ + domGles_pipeline_settings::domStencil_funcRef ref = new domGles_pipeline_settings::domStencil_func(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domStencil_func::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "stencil_func" ); + meta->registerClass(domGles_pipeline_settings::domStencil_func::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "func" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings::domStencil_func,elemFunc) ); + mea->setElementType( domGles_pipeline_settings::domStencil_func::domFunc::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "ref" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings::domStencil_func,elemRef) ); + mea->setElementType( domGles_pipeline_settings::domStencil_func::domRef::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 1, 1 ); + mea->setName( "mask" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings::domStencil_func,elemMask) ); + mea->setElementType( domGles_pipeline_settings::domStencil_func::domMask::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGles_pipeline_settings::domStencil_func)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domStencil_func::domFunc::create(DAE& dae) +{ + domGles_pipeline_settings::domStencil_func::domFuncRef ref = new domGles_pipeline_settings::domStencil_func::domFunc(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domStencil_func::domFunc::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "func" ); + meta->registerClass(domGles_pipeline_settings::domStencil_func::domFunc::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gl_func_type")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_func::domFunc , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "ALWAYS"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_func::domFunc , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domStencil_func::domFunc)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domStencil_func::domRef::create(DAE& dae) +{ + domGles_pipeline_settings::domStencil_func::domRefRef ref = new domGles_pipeline_settings::domStencil_func::domRef(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domStencil_func::domRef::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "ref" ); + meta->registerClass(domGles_pipeline_settings::domStencil_func::domRef::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedByte")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_func::domRef , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "0"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_func::domRef , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domStencil_func::domRef)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domStencil_func::domMask::create(DAE& dae) +{ + domGles_pipeline_settings::domStencil_func::domMaskRef ref = new domGles_pipeline_settings::domStencil_func::domMask(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domStencil_func::domMask::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mask" ); + meta->registerClass(domGles_pipeline_settings::domStencil_func::domMask::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedByte")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_func::domMask , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "255"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_func::domMask , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domStencil_func::domMask)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domStencil_mask::create(DAE& dae) +{ + domGles_pipeline_settings::domStencil_maskRef ref = new domGles_pipeline_settings::domStencil_mask(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domStencil_mask::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "stencil_mask" ); + meta->registerClass(domGles_pipeline_settings::domStencil_mask::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Int")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_mask , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "4294967295"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_mask , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domStencil_mask)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domStencil_op::create(DAE& dae) +{ + domGles_pipeline_settings::domStencil_opRef ref = new domGles_pipeline_settings::domStencil_op(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domStencil_op::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "stencil_op" ); + meta->registerClass(domGles_pipeline_settings::domStencil_op::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fail" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings::domStencil_op,elemFail) ); + mea->setElementType( domGles_pipeline_settings::domStencil_op::domFail::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "zfail" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings::domStencil_op,elemZfail) ); + mea->setElementType( domGles_pipeline_settings::domStencil_op::domZfail::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 1, 1 ); + mea->setName( "zpass" ); + mea->setOffset( daeOffsetOf(domGles_pipeline_settings::domStencil_op,elemZpass) ); + mea->setElementType( domGles_pipeline_settings::domStencil_op::domZpass::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGles_pipeline_settings::domStencil_op)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domStencil_op::domFail::create(DAE& dae) +{ + domGles_pipeline_settings::domStencil_op::domFailRef ref = new domGles_pipeline_settings::domStencil_op::domFail(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domStencil_op::domFail::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fail" ); + meta->registerClass(domGles_pipeline_settings::domStencil_op::domFail::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gles_stencil_op_type")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_op::domFail , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "KEEP"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_op::domFail , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domStencil_op::domFail)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domStencil_op::domZfail::create(DAE& dae) +{ + domGles_pipeline_settings::domStencil_op::domZfailRef ref = new domGles_pipeline_settings::domStencil_op::domZfail(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domStencil_op::domZfail::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "zfail" ); + meta->registerClass(domGles_pipeline_settings::domStencil_op::domZfail::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gles_stencil_op_type")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_op::domZfail , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "KEEP"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_op::domZfail , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domStencil_op::domZfail)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domStencil_op::domZpass::create(DAE& dae) +{ + domGles_pipeline_settings::domStencil_op::domZpassRef ref = new domGles_pipeline_settings::domStencil_op::domZpass(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domStencil_op::domZpass::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "zpass" ); + meta->registerClass(domGles_pipeline_settings::domStencil_op::domZpass::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Gles_stencil_op_type")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_op::domZpass , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "KEEP"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_op::domZpass , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domStencil_op::domZpass)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domAlpha_test_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domAlpha_test_enableRef ref = new domGles_pipeline_settings::domAlpha_test_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domAlpha_test_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "alpha_test_enable" ); + meta->registerClass(domGles_pipeline_settings::domAlpha_test_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domAlpha_test_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domAlpha_test_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domAlpha_test_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domBlend_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domBlend_enableRef ref = new domGles_pipeline_settings::domBlend_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domBlend_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "blend_enable" ); + meta->registerClass(domGles_pipeline_settings::domBlend_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domBlend_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domBlend_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domBlend_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domClip_plane_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domClip_plane_enableRef ref = new domGles_pipeline_settings::domClip_plane_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domClip_plane_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "clip_plane_enable" ); + meta->registerClass(domGles_pipeline_settings::domClip_plane_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domClip_plane_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domClip_plane_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GLES_MAX_CLIP_PLANES_index")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domClip_plane_enable , attrIndex )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domClip_plane_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domColor_logic_op_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domColor_logic_op_enableRef ref = new domGles_pipeline_settings::domColor_logic_op_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domColor_logic_op_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "color_logic_op_enable" ); + meta->registerClass(domGles_pipeline_settings::domColor_logic_op_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domColor_logic_op_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domColor_logic_op_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domColor_logic_op_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domColor_material_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domColor_material_enableRef ref = new domGles_pipeline_settings::domColor_material_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domColor_material_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "color_material_enable" ); + meta->registerClass(domGles_pipeline_settings::domColor_material_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domColor_material_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "true"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domColor_material_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domColor_material_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domCull_face_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domCull_face_enableRef ref = new domGles_pipeline_settings::domCull_face_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domCull_face_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "cull_face_enable" ); + meta->registerClass(domGles_pipeline_settings::domCull_face_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domCull_face_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domCull_face_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domCull_face_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domDepth_test_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domDepth_test_enableRef ref = new domGles_pipeline_settings::domDepth_test_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domDepth_test_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "depth_test_enable" ); + meta->registerClass(domGles_pipeline_settings::domDepth_test_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domDepth_test_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domDepth_test_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domDepth_test_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domDither_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domDither_enableRef ref = new domGles_pipeline_settings::domDither_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domDither_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "dither_enable" ); + meta->registerClass(domGles_pipeline_settings::domDither_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domDither_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domDither_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domDither_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domFog_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domFog_enableRef ref = new domGles_pipeline_settings::domFog_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domFog_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "fog_enable" ); + meta->registerClass(domGles_pipeline_settings::domFog_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domFog_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domFog_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domFog_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domTexture_pipeline_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domTexture_pipeline_enableRef ref = new domGles_pipeline_settings::domTexture_pipeline_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domTexture_pipeline_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "texture_pipeline_enable" ); + meta->registerClass(domGles_pipeline_settings::domTexture_pipeline_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domTexture_pipeline_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domTexture_pipeline_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domTexture_pipeline_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLight_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domLight_enableRef ref = new domGles_pipeline_settings::domLight_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLight_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_enable" ); + meta->registerClass(domGles_pipeline_settings::domLight_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: index + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "index" ); + ma->setType( dae.getAtomicTypes().get("GLES_MAX_LIGHTS_index")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_enable , attrIndex )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLight_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLighting_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domLighting_enableRef ref = new domGles_pipeline_settings::domLighting_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLighting_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "lighting_enable" ); + meta->registerClass(domGles_pipeline_settings::domLighting_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLighting_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLighting_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLighting_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLight_model_two_side_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domLight_model_two_side_enableRef ref = new domGles_pipeline_settings::domLight_model_two_side_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLight_model_two_side_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light_model_two_side_enable" ); + meta->registerClass(domGles_pipeline_settings::domLight_model_two_side_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_model_two_side_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLight_model_two_side_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLight_model_two_side_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domLine_smooth_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domLine_smooth_enableRef ref = new domGles_pipeline_settings::domLine_smooth_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domLine_smooth_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "line_smooth_enable" ); + meta->registerClass(domGles_pipeline_settings::domLine_smooth_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLine_smooth_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domLine_smooth_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domLine_smooth_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domMultisample_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domMultisample_enableRef ref = new domGles_pipeline_settings::domMultisample_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domMultisample_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "multisample_enable" ); + meta->registerClass(domGles_pipeline_settings::domMultisample_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domMultisample_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domMultisample_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domMultisample_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domNormalize_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domNormalize_enableRef ref = new domGles_pipeline_settings::domNormalize_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domNormalize_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "normalize_enable" ); + meta->registerClass(domGles_pipeline_settings::domNormalize_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domNormalize_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domNormalize_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domNormalize_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domPoint_smooth_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domPoint_smooth_enableRef ref = new domGles_pipeline_settings::domPoint_smooth_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domPoint_smooth_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "point_smooth_enable" ); + meta->registerClass(domGles_pipeline_settings::domPoint_smooth_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPoint_smooth_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPoint_smooth_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domPoint_smooth_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domPolygon_offset_fill_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domPolygon_offset_fill_enableRef ref = new domGles_pipeline_settings::domPolygon_offset_fill_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domPolygon_offset_fill_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "polygon_offset_fill_enable" ); + meta->registerClass(domGles_pipeline_settings::domPolygon_offset_fill_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPolygon_offset_fill_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domPolygon_offset_fill_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domPolygon_offset_fill_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domRescale_normal_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domRescale_normal_enableRef ref = new domGles_pipeline_settings::domRescale_normal_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domRescale_normal_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "rescale_normal_enable" ); + meta->registerClass(domGles_pipeline_settings::domRescale_normal_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domRescale_normal_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domRescale_normal_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domRescale_normal_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domSample_alpha_to_coverage_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domSample_alpha_to_coverage_enableRef ref = new domGles_pipeline_settings::domSample_alpha_to_coverage_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domSample_alpha_to_coverage_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "sample_alpha_to_coverage_enable" ); + meta->registerClass(domGles_pipeline_settings::domSample_alpha_to_coverage_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domSample_alpha_to_coverage_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domSample_alpha_to_coverage_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domSample_alpha_to_coverage_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domSample_alpha_to_one_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domSample_alpha_to_one_enableRef ref = new domGles_pipeline_settings::domSample_alpha_to_one_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domSample_alpha_to_one_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "sample_alpha_to_one_enable" ); + meta->registerClass(domGles_pipeline_settings::domSample_alpha_to_one_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domSample_alpha_to_one_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domSample_alpha_to_one_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domSample_alpha_to_one_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domSample_coverage_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domSample_coverage_enableRef ref = new domGles_pipeline_settings::domSample_coverage_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domSample_coverage_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "sample_coverage_enable" ); + meta->registerClass(domGles_pipeline_settings::domSample_coverage_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domSample_coverage_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domSample_coverage_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domSample_coverage_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domScissor_test_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domScissor_test_enableRef ref = new domGles_pipeline_settings::domScissor_test_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domScissor_test_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "scissor_test_enable" ); + meta->registerClass(domGles_pipeline_settings::domScissor_test_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domScissor_test_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domScissor_test_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domScissor_test_enable)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_pipeline_settings::domStencil_test_enable::create(DAE& dae) +{ + domGles_pipeline_settings::domStencil_test_enableRef ref = new domGles_pipeline_settings::domStencil_test_enable(dae); + return ref; +} + + +daeMetaElement * +domGles_pipeline_settings::domStencil_test_enable::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "stencil_test_enable" ); + meta->registerClass(domGles_pipeline_settings::domStencil_test_enable::create); + + meta->setIsInnerClass( true ); + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_test_enable , attrValue )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_pipeline_settings::domStencil_test_enable , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_pipeline_settings::domStencil_test_enable)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGles_sampler_state.cpp b/1.4.0/dom/src/1.4/dom/domGles_sampler_state.cpp new file mode 100644 index 0000000..35cfd1b --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGles_sampler_state.cpp @@ -0,0 +1,364 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGles_sampler_state.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGles_sampler_state::create(DAE& dae) +{ + domGles_sampler_stateRef ref = new domGles_sampler_state(dae); + return ref; +} + + +daeMetaElement * +domGles_sampler_state::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gles_sampler_state" ); + meta->registerClass(domGles_sampler_state::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "wrap_s" ); + mea->setOffset( daeOffsetOf(domGles_sampler_state,elemWrap_s) ); + mea->setElementType( domGles_sampler_state::domWrap_s::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "wrap_t" ); + mea->setOffset( daeOffsetOf(domGles_sampler_state,elemWrap_t) ); + mea->setElementType( domGles_sampler_state::domWrap_t::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "minfilter" ); + mea->setOffset( daeOffsetOf(domGles_sampler_state,elemMinfilter) ); + mea->setElementType( domGles_sampler_state::domMinfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "magfilter" ); + mea->setOffset( daeOffsetOf(domGles_sampler_state,elemMagfilter) ); + mea->setElementType( domGles_sampler_state::domMagfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "mipfilter" ); + mea->setOffset( daeOffsetOf(domGles_sampler_state,elemMipfilter) ); + mea->setElementType( domGles_sampler_state::domMipfilter::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "mipmap_maxlevel" ); + mea->setOffset( daeOffsetOf(domGles_sampler_state,elemMipmap_maxlevel) ); + mea->setElementType( domGles_sampler_state::domMipmap_maxlevel::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "mipmap_bias" ); + mea->setOffset( daeOffsetOf(domGles_sampler_state,elemMipmap_bias) ); + mea->setElementType( domGles_sampler_state::domMipmap_bias::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 7, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domGles_sampler_state,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 7 ); + meta->setCMRoot( cm ); + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_sampler_state , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_sampler_state)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_sampler_state::domWrap_s::create(DAE& dae) +{ + domGles_sampler_state::domWrap_sRef ref = new domGles_sampler_state::domWrap_s(dae); + return ref; +} + + +daeMetaElement * +domGles_sampler_state::domWrap_s::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "wrap_s" ); + meta->registerClass(domGles_sampler_state::domWrap_s::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Gles_sampler_wrap")); + ma->setOffset( daeOffsetOf( domGles_sampler_state::domWrap_s , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_sampler_state::domWrap_s)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_sampler_state::domWrap_t::create(DAE& dae) +{ + domGles_sampler_state::domWrap_tRef ref = new domGles_sampler_state::domWrap_t(dae); + return ref; +} + + +daeMetaElement * +domGles_sampler_state::domWrap_t::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "wrap_t" ); + meta->registerClass(domGles_sampler_state::domWrap_t::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Gles_sampler_wrap")); + ma->setOffset( daeOffsetOf( domGles_sampler_state::domWrap_t , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_sampler_state::domWrap_t)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_sampler_state::domMinfilter::create(DAE& dae) +{ + domGles_sampler_state::domMinfilterRef ref = new domGles_sampler_state::domMinfilter(dae); + return ref; +} + + +daeMetaElement * +domGles_sampler_state::domMinfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "minfilter" ); + meta->registerClass(domGles_sampler_state::domMinfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domGles_sampler_state::domMinfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_sampler_state::domMinfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_sampler_state::domMagfilter::create(DAE& dae) +{ + domGles_sampler_state::domMagfilterRef ref = new domGles_sampler_state::domMagfilter(dae); + return ref; +} + + +daeMetaElement * +domGles_sampler_state::domMagfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "magfilter" ); + meta->registerClass(domGles_sampler_state::domMagfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domGles_sampler_state::domMagfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_sampler_state::domMagfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_sampler_state::domMipfilter::create(DAE& dae) +{ + domGles_sampler_state::domMipfilterRef ref = new domGles_sampler_state::domMipfilter(dae); + return ref; +} + + +daeMetaElement * +domGles_sampler_state::domMipfilter::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipfilter" ); + meta->registerClass(domGles_sampler_state::domMipfilter::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_sampler_filter_common")); + ma->setOffset( daeOffsetOf( domGles_sampler_state::domMipfilter , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_sampler_state::domMipfilter)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_sampler_state::domMipmap_maxlevel::create(DAE& dae) +{ + domGles_sampler_state::domMipmap_maxlevelRef ref = new domGles_sampler_state::domMipmap_maxlevel(dae); + return ref; +} + + +daeMetaElement * +domGles_sampler_state::domMipmap_maxlevel::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipmap_maxlevel" ); + meta->registerClass(domGles_sampler_state::domMipmap_maxlevel::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsUnsignedByte")); + ma->setOffset( daeOffsetOf( domGles_sampler_state::domMipmap_maxlevel , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_sampler_state::domMipmap_maxlevel)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_sampler_state::domMipmap_bias::create(DAE& dae) +{ + domGles_sampler_state::domMipmap_biasRef ref = new domGles_sampler_state::domMipmap_bias(dae); + return ref; +} + + +daeMetaElement * +domGles_sampler_state::domMipmap_bias::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mipmap_bias" ); + meta->registerClass(domGles_sampler_state::domMipmap_bias::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsFloat")); + ma->setOffset( daeOffsetOf( domGles_sampler_state::domMipmap_bias , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_sampler_state::domMipmap_bias)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGles_texcombiner_argumentAlpha_type.cpp b/1.4.0/dom/src/1.4/dom/domGles_texcombiner_argumentAlpha_type.cpp new file mode 100644 index 0000000..ac360ce --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGles_texcombiner_argumentAlpha_type.cpp @@ -0,0 +1,82 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGles_texcombiner_argumentAlpha_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGles_texcombiner_argumentAlpha_type::create(DAE& dae) +{ + domGles_texcombiner_argumentAlpha_typeRef ref = new domGles_texcombiner_argumentAlpha_type(dae); + return ref; +} + + +daeMetaElement * +domGles_texcombiner_argumentAlpha_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gles_texcombiner_argumentAlpha_type" ); + meta->registerClass(domGles_texcombiner_argumentAlpha_type::create); + + + // Add attribute: source + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "source" ); + ma->setType( dae.getAtomicTypes().get("Gles_texcombiner_source_enums")); + ma->setOffset( daeOffsetOf( domGles_texcombiner_argumentAlpha_type , attrSource )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: operand + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "operand" ); + ma->setType( dae.getAtomicTypes().get("Gles_texcombiner_operandAlpha_enums")); + ma->setOffset( daeOffsetOf( domGles_texcombiner_argumentAlpha_type , attrOperand )); + ma->setContainer( meta ); + ma->setDefaultString( "SRC_ALPHA"); + + meta->appendAttribute(ma); + } + + // Add attribute: unit + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "unit" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_texcombiner_argumentAlpha_type , attrUnit )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_texcombiner_argumentAlpha_type)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGles_texcombiner_argumentRGB_type.cpp b/1.4.0/dom/src/1.4/dom/domGles_texcombiner_argumentRGB_type.cpp new file mode 100644 index 0000000..1656b81 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGles_texcombiner_argumentRGB_type.cpp @@ -0,0 +1,82 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGles_texcombiner_argumentRGB_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGles_texcombiner_argumentRGB_type::create(DAE& dae) +{ + domGles_texcombiner_argumentRGB_typeRef ref = new domGles_texcombiner_argumentRGB_type(dae); + return ref; +} + + +daeMetaElement * +domGles_texcombiner_argumentRGB_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gles_texcombiner_argumentRGB_type" ); + meta->registerClass(domGles_texcombiner_argumentRGB_type::create); + + + // Add attribute: source + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "source" ); + ma->setType( dae.getAtomicTypes().get("Gles_texcombiner_source_enums")); + ma->setOffset( daeOffsetOf( domGles_texcombiner_argumentRGB_type , attrSource )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: operand + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "operand" ); + ma->setType( dae.getAtomicTypes().get("Gles_texcombiner_operandRGB_enums")); + ma->setOffset( daeOffsetOf( domGles_texcombiner_argumentRGB_type , attrOperand )); + ma->setContainer( meta ); + ma->setDefaultString( "SRC_COLOR"); + + meta->appendAttribute(ma); + } + + // Add attribute: unit + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "unit" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_texcombiner_argumentRGB_type , attrUnit )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_texcombiner_argumentRGB_type)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGles_texcombiner_commandAlpha_type.cpp b/1.4.0/dom/src/1.4/dom/domGles_texcombiner_commandAlpha_type.cpp new file mode 100644 index 0000000..9dcfe9c --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGles_texcombiner_commandAlpha_type.cpp @@ -0,0 +1,82 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGles_texcombiner_commandAlpha_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGles_texcombiner_commandAlpha_type::create(DAE& dae) +{ + domGles_texcombiner_commandAlpha_typeRef ref = new domGles_texcombiner_commandAlpha_type(dae); + return ref; +} + + +daeMetaElement * +domGles_texcombiner_commandAlpha_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gles_texcombiner_commandAlpha_type" ); + meta->registerClass(domGles_texcombiner_commandAlpha_type::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 3 ); + mea->setName( "argument" ); + mea->setOffset( daeOffsetOf(domGles_texcombiner_commandAlpha_type,elemArgument_array) ); + mea->setElementType( domGles_texcombiner_argumentAlpha_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: operator + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "operator" ); + ma->setType( dae.getAtomicTypes().get("Gles_texcombiner_operatorAlpha_enums")); + ma->setOffset( daeOffsetOf( domGles_texcombiner_commandAlpha_type , attrOperator )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: scale + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "scale" ); + ma->setType( dae.getAtomicTypes().get("xsFloat")); + ma->setOffset( daeOffsetOf( domGles_texcombiner_commandAlpha_type , attrScale )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_texcombiner_commandAlpha_type)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGles_texcombiner_commandRGB_type.cpp b/1.4.0/dom/src/1.4/dom/domGles_texcombiner_commandRGB_type.cpp new file mode 100644 index 0000000..98b9afb --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGles_texcombiner_commandRGB_type.cpp @@ -0,0 +1,82 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGles_texcombiner_commandRGB_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGles_texcombiner_commandRGB_type::create(DAE& dae) +{ + domGles_texcombiner_commandRGB_typeRef ref = new domGles_texcombiner_commandRGB_type(dae); + return ref; +} + + +daeMetaElement * +domGles_texcombiner_commandRGB_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gles_texcombiner_commandRGB_type" ); + meta->registerClass(domGles_texcombiner_commandRGB_type::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 3 ); + mea->setName( "argument" ); + mea->setOffset( daeOffsetOf(domGles_texcombiner_commandRGB_type,elemArgument_array) ); + mea->setElementType( domGles_texcombiner_argumentRGB_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: operator + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "operator" ); + ma->setType( dae.getAtomicTypes().get("Gles_texcombiner_operatorRGB_enums")); + ma->setOffset( daeOffsetOf( domGles_texcombiner_commandRGB_type , attrOperator )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: scale + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "scale" ); + ma->setType( dae.getAtomicTypes().get("xsFloat")); + ma->setOffset( daeOffsetOf( domGles_texcombiner_commandRGB_type , attrScale )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_texcombiner_commandRGB_type)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGles_texcombiner_command_type.cpp b/1.4.0/dom/src/1.4/dom/domGles_texcombiner_command_type.cpp new file mode 100644 index 0000000..2d5dbe9 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGles_texcombiner_command_type.cpp @@ -0,0 +1,71 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGles_texcombiner_command_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGles_texcombiner_command_type::create(DAE& dae) +{ + domGles_texcombiner_command_typeRef ref = new domGles_texcombiner_command_type(dae); + return ref; +} + + +daeMetaElement * +domGles_texcombiner_command_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gles_texcombiner_command_type" ); + meta->registerClass(domGles_texcombiner_command_type::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "constant" ); + mea->setOffset( daeOffsetOf(domGles_texcombiner_command_type,elemConstant) ); + mea->setElementType( domGles_texture_constant_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "RGB" ); + mea->setOffset( daeOffsetOf(domGles_texcombiner_command_type,elemRGB) ); + mea->setElementType( domGles_texcombiner_commandRGB_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "alpha" ); + mea->setOffset( daeOffsetOf(domGles_texcombiner_command_type,elemAlpha) ); + mea->setElementType( domGles_texcombiner_commandAlpha_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domGles_texcombiner_command_type)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGles_texenv_command_type.cpp b/1.4.0/dom/src/1.4/dom/domGles_texenv_command_type.cpp new file mode 100644 index 0000000..b48b5bd --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGles_texenv_command_type.cpp @@ -0,0 +1,81 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGles_texenv_command_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGles_texenv_command_type::create(DAE& dae) +{ + domGles_texenv_command_typeRef ref = new domGles_texenv_command_type(dae); + return ref; +} + + +daeMetaElement * +domGles_texenv_command_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gles_texenv_command_type" ); + meta->registerClass(domGles_texenv_command_type::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "constant" ); + mea->setOffset( daeOffsetOf(domGles_texenv_command_type,elemConstant) ); + mea->setElementType( domGles_texture_constant_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: operator + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "operator" ); + ma->setType( dae.getAtomicTypes().get("Gles_texenv_mode_enums")); + ma->setOffset( daeOffsetOf( domGles_texenv_command_type , attrOperator )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: unit + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "unit" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_texenv_command_type , attrUnit )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_texenv_command_type)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGles_texture_constant_type.cpp b/1.4.0/dom/src/1.4/dom/domGles_texture_constant_type.cpp new file mode 100644 index 0000000..1ce7605 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGles_texture_constant_type.cpp @@ -0,0 +1,71 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGles_texture_constant_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGles_texture_constant_type::create(DAE& dae) +{ + domGles_texture_constant_typeRef ref = new domGles_texture_constant_type(dae); + return ref; +} + + +daeMetaElement * +domGles_texture_constant_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gles_texture_constant_type" ); + meta->registerClass(domGles_texture_constant_type::create); + + + // Add attribute: value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domGles_texture_constant_type , attrValue )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: param + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "param" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_texture_constant_type , attrParam )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_texture_constant_type)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGles_texture_pipeline.cpp b/1.4.0/dom/src/1.4/dom/domGles_texture_pipeline.cpp new file mode 100644 index 0000000..1dfa130 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGles_texture_pipeline.cpp @@ -0,0 +1,86 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGles_texture_pipeline.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGles_texture_pipeline::create(DAE& dae) +{ + domGles_texture_pipelineRef ref = new domGles_texture_pipeline(dae); + return ref; +} + + +daeMetaElement * +domGles_texture_pipeline::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gles_texture_pipeline" ); + meta->registerClass(domGles_texture_pipeline::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texcombiner" ); + mea->setOffset( daeOffsetOf(domGles_texture_pipeline,elemTexcombiner_array) ); + mea->setElementType( domGles_texcombiner_command_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "texenv" ); + mea->setOffset( daeOffsetOf(domGles_texture_pipeline,elemTexenv_array) ); + mea->setElementType( domGles_texenv_command_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domGles_texture_pipeline,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3000 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGles_texture_pipeline,_contents)); + meta->addContentsOrder(daeOffsetOf(domGles_texture_pipeline,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGles_texture_pipeline,_CMData), 1); + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_texture_pipeline , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_texture_pipeline)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGles_texture_unit.cpp b/1.4.0/dom/src/1.4/dom/domGles_texture_unit.cpp new file mode 100644 index 0000000..0b999c4 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGles_texture_unit.cpp @@ -0,0 +1,198 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGles_texture_unit.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGles_texture_unit::create(DAE& dae) +{ + domGles_texture_unitRef ref = new domGles_texture_unit(dae); + return ref; +} + + +daeMetaElement * +domGles_texture_unit::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "gles_texture_unit" ); + meta->registerClass(domGles_texture_unit::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "surface" ); + mea->setOffset( daeOffsetOf(domGles_texture_unit,elemSurface) ); + mea->setElementType( domGles_texture_unit::domSurface::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "sampler_state" ); + mea->setOffset( daeOffsetOf(domGles_texture_unit,elemSampler_state) ); + mea->setElementType( domGles_texture_unit::domSampler_state::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "texcoord" ); + mea->setOffset( daeOffsetOf(domGles_texture_unit,elemTexcoord) ); + mea->setElementType( domGles_texture_unit::domTexcoord::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domGles_texture_unit,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_texture_unit , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_texture_unit)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_texture_unit::domSurface::create(DAE& dae) +{ + domGles_texture_unit::domSurfaceRef ref = new domGles_texture_unit::domSurface(dae); + return ref; +} + + +daeMetaElement * +domGles_texture_unit::domSurface::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "surface" ); + meta->registerClass(domGles_texture_unit::domSurface::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_texture_unit::domSurface , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_texture_unit::domSurface)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_texture_unit::domSampler_state::create(DAE& dae) +{ + domGles_texture_unit::domSampler_stateRef ref = new domGles_texture_unit::domSampler_state(dae); + return ref; +} + + +daeMetaElement * +domGles_texture_unit::domSampler_state::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "sampler_state" ); + meta->registerClass(domGles_texture_unit::domSampler_state::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_texture_unit::domSampler_state , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_texture_unit::domSampler_state)); + meta->validate(); + + return meta; +} + +daeElementRef +domGles_texture_unit::domTexcoord::create(DAE& dae) +{ + domGles_texture_unit::domTexcoordRef ref = new domGles_texture_unit::domTexcoord(dae); + return ref; +} + + +daeMetaElement * +domGles_texture_unit::domTexcoord::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "texcoord" ); + meta->registerClass(domGles_texture_unit::domTexcoord::create); + + meta->setIsInnerClass( true ); + + // Add attribute: semantic + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "semantic" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGles_texture_unit::domTexcoord , attrSemantic )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGles_texture_unit::domTexcoord)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGlsl_newarray_type.cpp b/1.4.0/dom/src/1.4/dom/domGlsl_newarray_type.cpp new file mode 100644 index 0000000..a680be7 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGlsl_newarray_type.cpp @@ -0,0 +1,81 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGlsl_newarray_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGlsl_newarray_type::create(DAE& dae) +{ + domGlsl_newarray_typeRef ref = new domGlsl_newarray_type(dae); + return ref; +} + + +daeMetaElement * +domGlsl_newarray_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "glsl_newarray_type" ); + meta->registerClass(domGlsl_newarray_type::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "glsl_param_type" ); + mea->setOffset( daeOffsetOf(domGlsl_newarray_type,elemGlsl_param_type_array) ); + mea->setElementType( domGlsl_param_type::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "array" ); + mea->setOffset( daeOffsetOf(domGlsl_newarray_type,elemArray_array) ); + mea->setElementType( domGlsl_newarray_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3000 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGlsl_newarray_type,_contents)); + meta->addContentsOrder(daeOffsetOf(domGlsl_newarray_type,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGlsl_newarray_type,_CMData), 1); + // Add attribute: length + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "length" ); + ma->setType( dae.getAtomicTypes().get("xsPositiveInteger")); + ma->setOffset( daeOffsetOf( domGlsl_newarray_type , attrLength )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_newarray_type)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGlsl_newparam.cpp b/1.4.0/dom/src/1.4/dom/domGlsl_newparam.cpp new file mode 100644 index 0000000..1f4a2cf --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGlsl_newparam.cpp @@ -0,0 +1,177 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGlsl_newparam.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGlsl_newparam::create(DAE& dae) +{ + domGlsl_newparamRef ref = new domGlsl_newparam(dae); + return ref; +} + + +daeMetaElement * +domGlsl_newparam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "glsl_newparam" ); + meta->registerClass(domGlsl_newparam::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domGlsl_newparam,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "semantic" ); + mea->setOffset( daeOffsetOf(domGlsl_newparam,elemSemantic) ); + mea->setElementType( domGlsl_newparam::domSemantic::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "modifier" ); + mea->setOffset( daeOffsetOf(domGlsl_newparam,elemModifier) ); + mea->setElementType( domGlsl_newparam::domModifier::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 3, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "glsl_param_type" ); + mea->setOffset( daeOffsetOf(domGlsl_newparam,elemGlsl_param_type) ); + mea->setElementType( domGlsl_param_type::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "array" ); + mea->setOffset( daeOffsetOf(domGlsl_newparam,elemArray) ); + mea->setElementType( domGlsl_newarray_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGlsl_newparam,_contents)); + meta->addContentsOrder(daeOffsetOf(domGlsl_newparam,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGlsl_newparam,_CMData), 1); + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("Glsl_identifier")); + ma->setOffset( daeOffsetOf( domGlsl_newparam , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_newparam)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_newparam::domSemantic::create(DAE& dae) +{ + domGlsl_newparam::domSemanticRef ref = new domGlsl_newparam::domSemantic(dae); + return ref; +} + + +daeMetaElement * +domGlsl_newparam::domSemantic::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "semantic" ); + meta->registerClass(domGlsl_newparam::domSemantic::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGlsl_newparam::domSemantic , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_newparam::domSemantic)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_newparam::domModifier::create(DAE& dae) +{ + domGlsl_newparam::domModifierRef ref = new domGlsl_newparam::domModifier(dae); + return ref; +} + + +daeMetaElement * +domGlsl_newparam::domModifier::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "modifier" ); + meta->registerClass(domGlsl_newparam::domModifier::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_modifier_enum_common")); + ma->setOffset( daeOffsetOf( domGlsl_newparam::domModifier , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_newparam::domModifier)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGlsl_param_type.cpp b/1.4.0/dom/src/1.4/dom/domGlsl_param_type.cpp new file mode 100644 index 0000000..af7c205 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGlsl_param_type.cpp @@ -0,0 +1,772 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGlsl_param_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGlsl_param_type::create(DAE& dae) +{ + domGlsl_param_typeRef ref = new domGlsl_param_type(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "glsl_param_type" ); + meta->registerClass(domGlsl_param_type::create); + + meta->setIsTransparent( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemBool) ); + mea->setElementType( domGlsl_param_type::domBool::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool2" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemBool2) ); + mea->setElementType( domGlsl_param_type::domBool2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool3" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemBool3) ); + mea->setElementType( domGlsl_param_type::domBool3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool4" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemBool4) ); + mea->setElementType( domGlsl_param_type::domBool4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemFloat) ); + mea->setElementType( domGlsl_param_type::domFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemFloat2) ); + mea->setElementType( domGlsl_param_type::domFloat2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemFloat3) ); + mea->setElementType( domGlsl_param_type::domFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemFloat4) ); + mea->setElementType( domGlsl_param_type::domFloat4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float2x2" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemFloat2x2) ); + mea->setElementType( domGlsl_param_type::domFloat2x2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float3x3" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemFloat3x3) ); + mea->setElementType( domGlsl_param_type::domFloat3x3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float4x4" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemFloat4x4) ); + mea->setElementType( domGlsl_param_type::domFloat4x4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemInt) ); + mea->setElementType( domGlsl_param_type::domInt::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int2" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemInt2) ); + mea->setElementType( domGlsl_param_type::domInt2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int3" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemInt3) ); + mea->setElementType( domGlsl_param_type::domInt3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int4" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemInt4) ); + mea->setElementType( domGlsl_param_type::domInt4::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "surface" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemSurface) ); + mea->setElementType( domGlsl_surface_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sampler1D" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemSampler1D) ); + mea->setElementType( domGl_sampler1D::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sampler2D" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemSampler2D) ); + mea->setElementType( domGl_sampler2D::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sampler3D" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemSampler3D) ); + mea->setElementType( domGl_sampler3D::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "samplerCUBE" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemSamplerCUBE) ); + mea->setElementType( domGl_samplerCUBE::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "samplerRECT" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemSamplerRECT) ); + mea->setElementType( domGl_samplerRECT::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "samplerDEPTH" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemSamplerDEPTH) ); + mea->setElementType( domGl_samplerDEPTH::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "enum" ); + mea->setOffset( daeOffsetOf(domGlsl_param_type,elemEnum) ); + mea->setElementType( domGlsl_param_type::domEnum::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGlsl_param_type,_contents)); + meta->addContentsOrder(daeOffsetOf(domGlsl_param_type,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGlsl_param_type,_CMData), 1); + meta->setElementSize(sizeof(domGlsl_param_type)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domBool::create(DAE& dae) +{ + domGlsl_param_type::domBoolRef ref = new domGlsl_param_type::domBool(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domBool::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool" ); + meta->registerClass(domGlsl_param_type::domBool::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Glsl_bool")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domBool , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domBool)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domBool2::create(DAE& dae) +{ + domGlsl_param_type::domBool2Ref ref = new domGlsl_param_type::domBool2(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domBool2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool2" ); + meta->registerClass(domGlsl_param_type::domBool2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Glsl_bool2")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domBool2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domBool2)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domBool3::create(DAE& dae) +{ + domGlsl_param_type::domBool3Ref ref = new domGlsl_param_type::domBool3(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domBool3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool3" ); + meta->registerClass(domGlsl_param_type::domBool3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Glsl_bool3")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domBool3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domBool3)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domBool4::create(DAE& dae) +{ + domGlsl_param_type::domBool4Ref ref = new domGlsl_param_type::domBool4(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domBool4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bool4" ); + meta->registerClass(domGlsl_param_type::domBool4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Glsl_bool4")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domBool4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domBool4)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domFloat::create(DAE& dae) +{ + domGlsl_param_type::domFloatRef ref = new domGlsl_param_type::domFloat(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domFloat::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float" ); + meta->registerClass(domGlsl_param_type::domFloat::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Glsl_float")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domFloat , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domFloat)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domFloat2::create(DAE& dae) +{ + domGlsl_param_type::domFloat2Ref ref = new domGlsl_param_type::domFloat2(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domFloat2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2" ); + meta->registerClass(domGlsl_param_type::domFloat2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Glsl_float2")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domFloat2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domFloat2)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domFloat3::create(DAE& dae) +{ + domGlsl_param_type::domFloat3Ref ref = new domGlsl_param_type::domFloat3(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domFloat3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3" ); + meta->registerClass(domGlsl_param_type::domFloat3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Glsl_float3")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domFloat3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domFloat3)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domFloat4::create(DAE& dae) +{ + domGlsl_param_type::domFloat4Ref ref = new domGlsl_param_type::domFloat4(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domFloat4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4" ); + meta->registerClass(domGlsl_param_type::domFloat4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Glsl_float4")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domFloat4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domFloat4)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domFloat2x2::create(DAE& dae) +{ + domGlsl_param_type::domFloat2x2Ref ref = new domGlsl_param_type::domFloat2x2(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domFloat2x2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float2x2" ); + meta->registerClass(domGlsl_param_type::domFloat2x2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Glsl_float2x2")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domFloat2x2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domFloat2x2)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domFloat3x3::create(DAE& dae) +{ + domGlsl_param_type::domFloat3x3Ref ref = new domGlsl_param_type::domFloat3x3(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domFloat3x3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float3x3" ); + meta->registerClass(domGlsl_param_type::domFloat3x3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Glsl_float3x3")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domFloat3x3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domFloat3x3)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domFloat4x4::create(DAE& dae) +{ + domGlsl_param_type::domFloat4x4Ref ref = new domGlsl_param_type::domFloat4x4(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domFloat4x4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "float4x4" ); + meta->registerClass(domGlsl_param_type::domFloat4x4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Glsl_float4x4")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domFloat4x4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domFloat4x4)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domInt::create(DAE& dae) +{ + domGlsl_param_type::domIntRef ref = new domGlsl_param_type::domInt(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domInt::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int" ); + meta->registerClass(domGlsl_param_type::domInt::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Glsl_int")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domInt , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domInt)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domInt2::create(DAE& dae) +{ + domGlsl_param_type::domInt2Ref ref = new domGlsl_param_type::domInt2(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domInt2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int2" ); + meta->registerClass(domGlsl_param_type::domInt2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Glsl_int2")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domInt2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domInt2)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domInt3::create(DAE& dae) +{ + domGlsl_param_type::domInt3Ref ref = new domGlsl_param_type::domInt3(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domInt3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int3" ); + meta->registerClass(domGlsl_param_type::domInt3::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Glsl_int3")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domInt3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domInt3)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domInt4::create(DAE& dae) +{ + domGlsl_param_type::domInt4Ref ref = new domGlsl_param_type::domInt4(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domInt4::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int4" ); + meta->registerClass(domGlsl_param_type::domInt4::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Glsl_int4")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domInt4 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domInt4)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_param_type::domEnum::create(DAE& dae) +{ + domGlsl_param_type::domEnumRef ref = new domGlsl_param_type::domEnum(dae); + return ref; +} + + +daeMetaElement * +domGlsl_param_type::domEnum::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "enum" ); + meta->registerClass(domGlsl_param_type::domEnum::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Gl_enumeration")); + ma->setOffset( daeOffsetOf( domGlsl_param_type::domEnum , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_param_type::domEnum)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGlsl_setarray_type.cpp b/1.4.0/dom/src/1.4/dom/domGlsl_setarray_type.cpp new file mode 100644 index 0000000..6d96a42 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGlsl_setarray_type.cpp @@ -0,0 +1,81 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGlsl_setarray_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGlsl_setarray_type::create(DAE& dae) +{ + domGlsl_setarray_typeRef ref = new domGlsl_setarray_type(dae); + return ref; +} + + +daeMetaElement * +domGlsl_setarray_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "glsl_setarray_type" ); + meta->registerClass(domGlsl_setarray_type::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "glsl_param_type" ); + mea->setOffset( daeOffsetOf(domGlsl_setarray_type,elemGlsl_param_type_array) ); + mea->setElementType( domGlsl_param_type::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "array" ); + mea->setOffset( daeOffsetOf(domGlsl_setarray_type,elemArray_array) ); + mea->setElementType( domGlsl_setarray_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3000 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGlsl_setarray_type,_contents)); + meta->addContentsOrder(daeOffsetOf(domGlsl_setarray_type,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGlsl_setarray_type,_CMData), 1); + // Add attribute: length + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "length" ); + ma->setType( dae.getAtomicTypes().get("xsPositiveInteger")); + ma->setOffset( daeOffsetOf( domGlsl_setarray_type , attrLength )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_setarray_type)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGlsl_setparam.cpp b/1.4.0/dom/src/1.4/dom/domGlsl_setparam.cpp new file mode 100644 index 0000000..c73c8a4 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGlsl_setparam.cpp @@ -0,0 +1,104 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGlsl_setparam.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGlsl_setparam::create(DAE& dae) +{ + domGlsl_setparamRef ref = new domGlsl_setparam(dae); + return ref; +} + + +daeMetaElement * +domGlsl_setparam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "glsl_setparam" ); + meta->registerClass(domGlsl_setparam::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domGlsl_setparam,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "glsl_param_type" ); + mea->setOffset( daeOffsetOf(domGlsl_setparam,elemGlsl_param_type) ); + mea->setElementType( domGlsl_param_type::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "array" ); + mea->setOffset( daeOffsetOf(domGlsl_setparam,elemArray) ); + mea->setElementType( domGlsl_setarray_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGlsl_setparam,_contents)); + meta->addContentsOrder(daeOffsetOf(domGlsl_setparam,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGlsl_setparam,_CMData), 1); + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("Glsl_identifier")); + ma->setOffset( daeOffsetOf( domGlsl_setparam , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: program + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "program" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGlsl_setparam , attrProgram )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_setparam)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGlsl_setparam_simple.cpp b/1.4.0/dom/src/1.4/dom/domGlsl_setparam_simple.cpp new file mode 100644 index 0000000..1c674de --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGlsl_setparam_simple.cpp @@ -0,0 +1,77 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGlsl_setparam_simple.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGlsl_setparam_simple::create(DAE& dae) +{ + domGlsl_setparam_simpleRef ref = new domGlsl_setparam_simple(dae); + return ref; +} + + +daeMetaElement * +domGlsl_setparam_simple::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "glsl_setparam_simple" ); + meta->registerClass(domGlsl_setparam_simple::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domGlsl_setparam_simple,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "glsl_param_type" ); + mea->setOffset( daeOffsetOf(domGlsl_setparam_simple,elemGlsl_param_type) ); + mea->setElementType( domGlsl_param_type::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 1, 1, 1 ) ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("Glsl_identifier")); + ma->setOffset( daeOffsetOf( domGlsl_setparam_simple , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_setparam_simple)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domGlsl_surface_type.cpp b/1.4.0/dom/src/1.4/dom/domGlsl_surface_type.cpp new file mode 100644 index 0000000..70e8ddb --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domGlsl_surface_type.cpp @@ -0,0 +1,262 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domGlsl_surface_type.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domGlsl_surface_type::create(DAE& dae) +{ + domGlsl_surface_typeRef ref = new domGlsl_surface_type(dae); + return ref; +} + + +daeMetaElement * +domGlsl_surface_type::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "glsl_surface_type" ); + meta->registerClass(domGlsl_surface_type::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "fx_surface_init_common" ); + mea->setOffset( daeOffsetOf(domGlsl_surface_type,elemFx_surface_init_common) ); + mea->setElementType( domFx_surface_init_common::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 0, 1 ) ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "format" ); + mea->setOffset( daeOffsetOf(domGlsl_surface_type,elemFormat) ); + mea->setElementType( domFormat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "format_hint" ); + mea->setOffset( daeOffsetOf(domGlsl_surface_type,elemFormat_hint) ); + mea->setElementType( domFx_surface_format_hint_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 3, 0, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "size" ); + mea->setOffset( daeOffsetOf(domGlsl_surface_type,elemSize) ); + mea->setElementType( domSize::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "viewport_ratio" ); + mea->setOffset( daeOffsetOf(domGlsl_surface_type,elemViewport_ratio) ); + mea->setElementType( domViewport_ratio::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "mip_levels" ); + mea->setOffset( daeOffsetOf(domGlsl_surface_type,elemMip_levels) ); + mea->setElementType( domMip_levels::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "mipmap_generate" ); + mea->setOffset( daeOffsetOf(domGlsl_surface_type,elemMipmap_generate) ); + mea->setElementType( domMipmap_generate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 6, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domGlsl_surface_type,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 6 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm = new daeMetaSequence( meta, cm, 7, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "generator" ); + mea->setOffset( daeOffsetOf(domGlsl_surface_type,elemGenerator) ); + mea->setElementType( domGenerator::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 7 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGlsl_surface_type,_contents)); + meta->addContentsOrder(daeOffsetOf(domGlsl_surface_type,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGlsl_surface_type,_CMData), 1); + // Add attribute: type + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "type" ); + ma->setType( dae.getAtomicTypes().get("Fx_surface_type_enum")); + ma->setOffset( daeOffsetOf( domGlsl_surface_type , attrType )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_surface_type)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_surface_type::domGenerator::create(DAE& dae) +{ + domGlsl_surface_type::domGeneratorRef ref = new domGlsl_surface_type::domGenerator(dae); + return ref; +} + + +daeMetaElement * +domGlsl_surface_type::domGenerator::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "generator" ); + meta->registerClass(domGlsl_surface_type::domGenerator::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domGlsl_surface_type::domGenerator,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 1, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "code" ); + mea->setOffset( daeOffsetOf(domGlsl_surface_type::domGenerator,elemCode_array) ); + mea->setElementType( domFx_code_profile::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "include" ); + mea->setOffset( daeOffsetOf(domGlsl_surface_type::domGenerator,elemInclude_array) ); + mea->setElementType( domFx_include_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementAttribute( meta, cm, 3002, 1, 1 ); + mea->setName( "name" ); + mea->setOffset( daeOffsetOf(domGlsl_surface_type::domGenerator,elemName) ); + mea->setElementType( domGlsl_surface_type::domGenerator::domName::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3003, 0, -1 ); + mea->setName( "setparam" ); + mea->setOffset( daeOffsetOf(domGlsl_surface_type::domGenerator,elemSetparam_array) ); + mea->setElementType( domGlsl_setparam_simple::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3003 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domGlsl_surface_type::domGenerator,_contents)); + meta->addContentsOrder(daeOffsetOf(domGlsl_surface_type::domGenerator,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domGlsl_surface_type::domGenerator,_CMData), 1); + meta->setElementSize(sizeof(domGlsl_surface_type::domGenerator)); + meta->validate(); + + return meta; +} + +daeElementRef +domGlsl_surface_type::domGenerator::domName::create(DAE& dae) +{ + domGlsl_surface_type::domGenerator::domNameRef ref = new domGlsl_surface_type::domGenerator::domName(dae); + return ref; +} + + +daeMetaElement * +domGlsl_surface_type::domGenerator::domName::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "name" ); + meta->registerClass(domGlsl_surface_type::domGenerator::domName::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGlsl_surface_type::domGenerator::domName , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: source + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "source" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domGlsl_surface_type::domGenerator::domName , attrSource )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domGlsl_surface_type::domGenerator::domName)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domIDREF_array.cpp b/1.4.0/dom/src/1.4/dom/domIDREF_array.cpp new file mode 100644 index 0000000..b80d145 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domIDREF_array.cpp @@ -0,0 +1,90 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domIDREF_array.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domIDREF_array::create(DAE& dae) +{ + domIDREF_arrayRef ref = new domIDREF_array(dae); + return ref; +} + + +daeMetaElement * +domIDREF_array::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "IDREF_array" ); + meta->registerClass(domIDREF_array::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsIDREFS")); + ma->setOffset( daeOffsetOf( domIDREF_array , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domIDREF_array , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domIDREF_array , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: count + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "count" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domIDREF_array , attrCount )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domIDREF_array)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domImage.cpp b/1.4.0/dom/src/1.4/dom/domImage.cpp new file mode 100644 index 0000000..707bd09 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domImage.cpp @@ -0,0 +1,226 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domImage.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domImage::create(DAE& dae) +{ + domImageRef ref = new domImage(dae); + return ref; +} + + +daeMetaElement * +domImage::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "image" ); + meta->registerClass(domImage::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domImage,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "data" ); + mea->setOffset( daeOffsetOf(domImage,elemData) ); + mea->setElementType( domImage::domData::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "init_from" ); + mea->setOffset( daeOffsetOf(domImage,elemInit_from) ); + mea->setElementType( domImage::domInit_from::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domImage,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domImage,_contents)); + meta->addContentsOrder(daeOffsetOf(domImage,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domImage,_CMData), 1); + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domImage , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domImage , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: format + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "format" ); + ma->setType( dae.getAtomicTypes().get("xsToken")); + ma->setOffset( daeOffsetOf( domImage , attrFormat )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: height + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "height" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domImage , attrHeight )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: width + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "width" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domImage , attrWidth )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: depth + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "depth" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domImage , attrDepth )); + ma->setContainer( meta ); + ma->setDefaultString( "1"); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domImage)); + meta->validate(); + + return meta; +} + +daeElementRef +domImage::domData::create(DAE& dae) +{ + domImage::domDataRef ref = new domImage::domData(dae); + return ref; +} + + +daeMetaElement * +domImage::domData::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "data" ); + meta->registerClass(domImage::domData::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("ListOfHexBinary")); + ma->setOffset( daeOffsetOf( domImage::domData , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domImage::domData)); + meta->validate(); + + return meta; +} + +daeElementRef +domImage::domInit_from::create(DAE& dae) +{ + domImage::domInit_fromRef ref = new domImage::domInit_from(dae); + return ref; +} + + +daeMetaElement * +domImage::domInit_from::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "init_from" ); + meta->registerClass(domImage::domInit_from::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domImage::domInit_from , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domImage::domInit_from)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInputGlobal.cpp b/1.4.0/dom/src/1.4/dom/domInputGlobal.cpp new file mode 100644 index 0000000..fc88570 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInputGlobal.cpp @@ -0,0 +1,71 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInputGlobal.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInputGlobal::create(DAE& dae) +{ + domInputGlobalRef ref = new domInputGlobal(dae); + return ref; +} + + +daeMetaElement * +domInputGlobal::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "InputGlobal" ); + meta->registerClass(domInputGlobal::create); + + + // Add attribute: semantic + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "semantic" ); + ma->setType( dae.getAtomicTypes().get("xsNMTOKEN")); + ma->setOffset( daeOffsetOf( domInputGlobal , attrSemantic )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: source + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "source" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domInputGlobal , attrSource )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInputGlobal)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInputLocal.cpp b/1.4.0/dom/src/1.4/dom/domInputLocal.cpp new file mode 100644 index 0000000..6f7b68a --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInputLocal.cpp @@ -0,0 +1,71 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInputLocal.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInputLocal::create(DAE& dae) +{ + domInputLocalRef ref = new domInputLocal(dae); + return ref; +} + + +daeMetaElement * +domInputLocal::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "InputLocal" ); + meta->registerClass(domInputLocal::create); + + + // Add attribute: semantic + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "semantic" ); + ma->setType( dae.getAtomicTypes().get("xsNMTOKEN")); + ma->setOffset( daeOffsetOf( domInputLocal , attrSemantic )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: source + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "source" ); + ma->setType( dae.getAtomicTypes().get("URIFragmentType")); + ma->setOffset( daeOffsetOf( domInputLocal , attrSource )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInputLocal)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInputLocalOffset.cpp b/1.4.0/dom/src/1.4/dom/domInputLocalOffset.cpp new file mode 100644 index 0000000..b529a63 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInputLocalOffset.cpp @@ -0,0 +1,94 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInputLocalOffset.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInputLocalOffset::create(DAE& dae) +{ + domInputLocalOffsetRef ref = new domInputLocalOffset(dae); + return ref; +} + + +daeMetaElement * +domInputLocalOffset::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "InputLocalOffset" ); + meta->registerClass(domInputLocalOffset::create); + + + // Add attribute: offset + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "offset" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domInputLocalOffset , attrOffset )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: semantic + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "semantic" ); + ma->setType( dae.getAtomicTypes().get("xsNMTOKEN")); + ma->setOffset( daeOffsetOf( domInputLocalOffset , attrSemantic )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: source + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "source" ); + ma->setType( dae.getAtomicTypes().get("URIFragmentType")); + ma->setOffset( daeOffsetOf( domInputLocalOffset , attrSource )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: set + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "set" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domInputLocalOffset , attrSet )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInputLocalOffset)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInstanceWithExtra.cpp b/1.4.0/dom/src/1.4/dom/domInstanceWithExtra.cpp new file mode 100644 index 0000000..1f045b3 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInstanceWithExtra.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInstanceWithExtra.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInstanceWithExtra::create(DAE& dae) +{ + domInstanceWithExtraRef ref = new domInstanceWithExtra(dae); + return ref; +} + + +daeMetaElement * +domInstanceWithExtra::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "InstanceWithExtra" ); + meta->registerClass(domInstanceWithExtra::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domInstanceWithExtra,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: url + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "url" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domInstanceWithExtra , attrUrl )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstanceWithExtra , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstanceWithExtra , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstanceWithExtra)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInstance_camera.cpp b/1.4.0/dom/src/1.4/dom/domInstance_camera.cpp new file mode 100644 index 0000000..9c083cd --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInstance_camera.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInstance_camera.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInstance_camera::create(DAE& dae) +{ + domInstance_cameraRef ref = new domInstance_camera(dae); + return ref; +} + + +daeMetaElement * +domInstance_camera::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "instance_camera" ); + meta->registerClass(domInstance_camera::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domInstance_camera,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: url + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "url" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domInstance_camera , attrUrl )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_camera , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_camera , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_camera)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInstance_controller.cpp b/1.4.0/dom/src/1.4/dom/domInstance_controller.cpp new file mode 100644 index 0000000..6aff381 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInstance_controller.cpp @@ -0,0 +1,141 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInstance_controller.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInstance_controller::create(DAE& dae) +{ + domInstance_controllerRef ref = new domInstance_controller(dae); + return ref; +} + + +daeMetaElement * +domInstance_controller::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "instance_controller" ); + meta->registerClass(domInstance_controller::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "skeleton" ); + mea->setOffset( daeOffsetOf(domInstance_controller,elemSkeleton_array) ); + mea->setElementType( domInstance_controller::domSkeleton::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "bind_material" ); + mea->setOffset( daeOffsetOf(domInstance_controller,elemBind_material) ); + mea->setElementType( domBind_material::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domInstance_controller,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: url + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "url" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domInstance_controller , attrUrl )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_controller , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_controller , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_controller)); + meta->validate(); + + return meta; +} + +daeElementRef +domInstance_controller::domSkeleton::create(DAE& dae) +{ + domInstance_controller::domSkeletonRef ref = new domInstance_controller::domSkeleton(dae); + return ref; +} + + +daeMetaElement * +domInstance_controller::domSkeleton::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "skeleton" ); + meta->registerClass(domInstance_controller::domSkeleton::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domInstance_controller::domSkeleton , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_controller::domSkeleton)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInstance_effect.cpp b/1.4.0/dom/src/1.4/dom/domInstance_effect.cpp new file mode 100644 index 0000000..900294b --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInstance_effect.cpp @@ -0,0 +1,219 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInstance_effect.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInstance_effect::create(DAE& dae) +{ + domInstance_effectRef ref = new domInstance_effect(dae); + return ref; +} + + +daeMetaElement * +domInstance_effect::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "instance_effect" ); + meta->registerClass(domInstance_effect::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "technique_hint" ); + mea->setOffset( daeOffsetOf(domInstance_effect,elemTechnique_hint_array) ); + mea->setElementType( domInstance_effect::domTechnique_hint::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "setparam" ); + mea->setOffset( daeOffsetOf(domInstance_effect,elemSetparam_array) ); + mea->setElementType( domInstance_effect::domSetparam::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domInstance_effect,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: url + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "url" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domInstance_effect , attrUrl )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_effect , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_effect , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_effect)); + meta->validate(); + + return meta; +} + +daeElementRef +domInstance_effect::domTechnique_hint::create(DAE& dae) +{ + domInstance_effect::domTechnique_hintRef ref = new domInstance_effect::domTechnique_hint(dae); + return ref; +} + + +daeMetaElement * +domInstance_effect::domTechnique_hint::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "technique_hint" ); + meta->registerClass(domInstance_effect::domTechnique_hint::create); + + meta->setIsInnerClass( true ); + + // Add attribute: platform + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "platform" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_effect::domTechnique_hint , attrPlatform )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: profile + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "profile" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_effect::domTechnique_hint , attrProfile )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_effect::domTechnique_hint , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_effect::domTechnique_hint)); + meta->validate(); + + return meta; +} + +daeElementRef +domInstance_effect::domSetparam::create(DAE& dae) +{ + domInstance_effect::domSetparamRef ref = new domInstance_effect::domSetparam(dae); + return ref; +} + + +daeMetaElement * +domInstance_effect::domSetparam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "setparam" ); + meta->registerClass(domInstance_effect::domSetparam::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "fx_basic_type_common" ); + mea->setOffset( daeOffsetOf(domInstance_effect::domSetparam,elemFx_basic_type_common) ); + mea->setElementType( domFx_basic_type_common::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("xsToken")); + ma->setOffset( daeOffsetOf( domInstance_effect::domSetparam , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_effect::domSetparam)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInstance_force_field.cpp b/1.4.0/dom/src/1.4/dom/domInstance_force_field.cpp new file mode 100644 index 0000000..42fe120 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInstance_force_field.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInstance_force_field.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInstance_force_field::create(DAE& dae) +{ + domInstance_force_fieldRef ref = new domInstance_force_field(dae); + return ref; +} + + +daeMetaElement * +domInstance_force_field::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "instance_force_field" ); + meta->registerClass(domInstance_force_field::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domInstance_force_field,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: url + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "url" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domInstance_force_field , attrUrl )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_force_field , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_force_field , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_force_field)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInstance_geometry.cpp b/1.4.0/dom/src/1.4/dom/domInstance_geometry.cpp new file mode 100644 index 0000000..5480205 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInstance_geometry.cpp @@ -0,0 +1,99 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInstance_geometry.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInstance_geometry::create(DAE& dae) +{ + domInstance_geometryRef ref = new domInstance_geometry(dae); + return ref; +} + + +daeMetaElement * +domInstance_geometry::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "instance_geometry" ); + meta->registerClass(domInstance_geometry::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "bind_material" ); + mea->setOffset( daeOffsetOf(domInstance_geometry,elemBind_material) ); + mea->setElementType( domBind_material::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domInstance_geometry,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + // Add attribute: url + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "url" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domInstance_geometry , attrUrl )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_geometry , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_geometry , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_geometry)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInstance_light.cpp b/1.4.0/dom/src/1.4/dom/domInstance_light.cpp new file mode 100644 index 0000000..0d7073a --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInstance_light.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInstance_light.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInstance_light::create(DAE& dae) +{ + domInstance_lightRef ref = new domInstance_light(dae); + return ref; +} + + +daeMetaElement * +domInstance_light::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "instance_light" ); + meta->registerClass(domInstance_light::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domInstance_light,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: url + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "url" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domInstance_light , attrUrl )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_light , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_light , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_light)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInstance_material.cpp b/1.4.0/dom/src/1.4/dom/domInstance_material.cpp new file mode 100644 index 0000000..7bd0bed --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInstance_material.cpp @@ -0,0 +1,230 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInstance_material.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInstance_material::create(DAE& dae) +{ + domInstance_materialRef ref = new domInstance_material(dae); + return ref; +} + + +daeMetaElement * +domInstance_material::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "instance_material" ); + meta->registerClass(domInstance_material::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "bind" ); + mea->setOffset( daeOffsetOf(domInstance_material,elemBind_array) ); + mea->setElementType( domInstance_material::domBind::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "bind_vertex_input" ); + mea->setOffset( daeOffsetOf(domInstance_material,elemBind_vertex_input_array) ); + mea->setElementType( domInstance_material::domBind_vertex_input::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domInstance_material,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: symbol + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "symbol" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_material , attrSymbol )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: target + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "target" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domInstance_material , attrTarget )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_material , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_material , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_material)); + meta->validate(); + + return meta; +} + +daeElementRef +domInstance_material::domBind::create(DAE& dae) +{ + domInstance_material::domBindRef ref = new domInstance_material::domBind(dae); + return ref; +} + + +daeMetaElement * +domInstance_material::domBind::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bind" ); + meta->registerClass(domInstance_material::domBind::create); + + meta->setIsInnerClass( true ); + + // Add attribute: semantic + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "semantic" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_material::domBind , attrSemantic )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: target + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "target" ); + ma->setType( dae.getAtomicTypes().get("xsToken")); + ma->setOffset( daeOffsetOf( domInstance_material::domBind , attrTarget )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_material::domBind)); + meta->validate(); + + return meta; +} + +daeElementRef +domInstance_material::domBind_vertex_input::create(DAE& dae) +{ + domInstance_material::domBind_vertex_inputRef ref = new domInstance_material::domBind_vertex_input(dae); + return ref; +} + + +daeMetaElement * +domInstance_material::domBind_vertex_input::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bind_vertex_input" ); + meta->registerClass(domInstance_material::domBind_vertex_input::create); + + meta->setIsInnerClass( true ); + + // Add attribute: semantic + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "semantic" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_material::domBind_vertex_input , attrSemantic )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: input_semantic + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "input_semantic" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_material::domBind_vertex_input , attrInput_semantic )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: input_set + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "input_set" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domInstance_material::domBind_vertex_input , attrInput_set )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_material::domBind_vertex_input)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInstance_node.cpp b/1.4.0/dom/src/1.4/dom/domInstance_node.cpp new file mode 100644 index 0000000..1521467 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInstance_node.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInstance_node.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInstance_node::create(DAE& dae) +{ + domInstance_nodeRef ref = new domInstance_node(dae); + return ref; +} + + +daeMetaElement * +domInstance_node::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "instance_node" ); + meta->registerClass(domInstance_node::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domInstance_node,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: url + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "url" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domInstance_node , attrUrl )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_node , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_node , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_node)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInstance_physics_material.cpp b/1.4.0/dom/src/1.4/dom/domInstance_physics_material.cpp new file mode 100644 index 0000000..56e360e --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInstance_physics_material.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInstance_physics_material.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInstance_physics_material::create(DAE& dae) +{ + domInstance_physics_materialRef ref = new domInstance_physics_material(dae); + return ref; +} + + +daeMetaElement * +domInstance_physics_material::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "instance_physics_material" ); + meta->registerClass(domInstance_physics_material::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domInstance_physics_material,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: url + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "url" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domInstance_physics_material , attrUrl )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_physics_material , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_physics_material , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_physics_material)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInstance_physics_model.cpp b/1.4.0/dom/src/1.4/dom/domInstance_physics_model.cpp new file mode 100644 index 0000000..c13969e --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInstance_physics_model.cpp @@ -0,0 +1,122 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInstance_physics_model.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInstance_physics_model::create(DAE& dae) +{ + domInstance_physics_modelRef ref = new domInstance_physics_model(dae); + return ref; +} + + +daeMetaElement * +domInstance_physics_model::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "instance_physics_model" ); + meta->registerClass(domInstance_physics_model::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "instance_force_field" ); + mea->setOffset( daeOffsetOf(domInstance_physics_model,elemInstance_force_field_array) ); + mea->setElementType( domInstance_force_field::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "instance_rigid_body" ); + mea->setOffset( daeOffsetOf(domInstance_physics_model,elemInstance_rigid_body_array) ); + mea->setElementType( domInstance_rigid_body::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "instance_rigid_constraint" ); + mea->setOffset( daeOffsetOf(domInstance_physics_model,elemInstance_rigid_constraint_array) ); + mea->setElementType( domInstance_rigid_constraint::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domInstance_physics_model,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + // Add attribute: url + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "url" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domInstance_physics_model , attrUrl )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_physics_model , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_physics_model , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: parent + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "parent" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domInstance_physics_model , attrParent )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_physics_model)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInstance_rigid_body.cpp b/1.4.0/dom/src/1.4/dom/domInstance_rigid_body.cpp new file mode 100644 index 0000000..f9e3e1c --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInstance_rigid_body.cpp @@ -0,0 +1,580 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInstance_rigid_body.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInstance_rigid_body::create(DAE& dae) +{ + domInstance_rigid_bodyRef ref = new domInstance_rigid_body(dae); + return ref; +} + + +daeMetaElement * +domInstance_rigid_body::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "instance_rigid_body" ); + meta->registerClass(domInstance_rigid_body::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "technique_common" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body,elemTechnique_common) ); + mea->setElementType( domInstance_rigid_body::domTechnique_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body,elemTechnique_array) ); + mea->setElementType( domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: body + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "body" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_rigid_body , attrBody )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_rigid_body , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_rigid_body , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: target + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "target" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domInstance_rigid_body , attrTarget )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_rigid_body)); + meta->validate(); + + return meta; +} + +daeElementRef +domInstance_rigid_body::domTechnique_common::create(DAE& dae) +{ + domInstance_rigid_body::domTechnique_commonRef ref = new domInstance_rigid_body::domTechnique_common(dae); + return ref; +} + + +daeMetaElement * +domInstance_rigid_body::domTechnique_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "technique_common" ); + meta->registerClass(domInstance_rigid_body::domTechnique_common::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "angular_velocity" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common,elemAngular_velocity) ); + mea->setElementType( domInstance_rigid_body::domTechnique_common::domAngular_velocity::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "velocity" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common,elemVelocity) ); + mea->setElementType( domInstance_rigid_body::domTechnique_common::domVelocity::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "dynamic" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common,elemDynamic) ); + mea->setElementType( domInstance_rigid_body::domTechnique_common::domDynamic::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "mass" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common,elemMass) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "mass_frame" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common,elemMass_frame) ); + mea->setElementType( domInstance_rigid_body::domTechnique_common::domMass_frame::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "inertia" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common,elemInertia) ); + mea->setElementType( domTargetableFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 6, 0, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "instance_physics_material" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common,elemInstance_physics_material) ); + mea->setElementType( domInstance_physics_material::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "physics_material" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common,elemPhysics_material) ); + mea->setElementType( domPhysics_material::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 7, 0, -1 ); + mea->setName( "shape" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common,elemShape_array) ); + mea->setElementType( domInstance_rigid_body::domTechnique_common::domShape::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 7 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domInstance_rigid_body::domTechnique_common,_contents)); + meta->addContentsOrder(daeOffsetOf(domInstance_rigid_body::domTechnique_common,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domInstance_rigid_body::domTechnique_common,_CMData), 1); + meta->setElementSize(sizeof(domInstance_rigid_body::domTechnique_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domInstance_rigid_body::domTechnique_common::domAngular_velocity::create(DAE& dae) +{ + domInstance_rigid_body::domTechnique_common::domAngular_velocityRef ref = new domInstance_rigid_body::domTechnique_common::domAngular_velocity(dae); + return ref; +} + + +daeMetaElement * +domInstance_rigid_body::domTechnique_common::domAngular_velocity::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "angular_velocity" ); + meta->registerClass(domInstance_rigid_body::domTechnique_common::domAngular_velocity::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domInstance_rigid_body::domTechnique_common::domAngular_velocity , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_rigid_body::domTechnique_common::domAngular_velocity)); + meta->validate(); + + return meta; +} + +daeElementRef +domInstance_rigid_body::domTechnique_common::domVelocity::create(DAE& dae) +{ + domInstance_rigid_body::domTechnique_common::domVelocityRef ref = new domInstance_rigid_body::domTechnique_common::domVelocity(dae); + return ref; +} + + +daeMetaElement * +domInstance_rigid_body::domTechnique_common::domVelocity::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "velocity" ); + meta->registerClass(domInstance_rigid_body::domTechnique_common::domVelocity::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domInstance_rigid_body::domTechnique_common::domVelocity , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_rigid_body::domTechnique_common::domVelocity)); + meta->validate(); + + return meta; +} + +daeElementRef +domInstance_rigid_body::domTechnique_common::domDynamic::create(DAE& dae) +{ + domInstance_rigid_body::domTechnique_common::domDynamicRef ref = new domInstance_rigid_body::domTechnique_common::domDynamic(dae); + return ref; +} + + +daeMetaElement * +domInstance_rigid_body::domTechnique_common::domDynamic::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "dynamic" ); + meta->registerClass(domInstance_rigid_body::domTechnique_common::domDynamic::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domInstance_rigid_body::domTechnique_common::domDynamic , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_rigid_body::domTechnique_common::domDynamic , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_rigid_body::domTechnique_common::domDynamic)); + meta->validate(); + + return meta; +} + +daeElementRef +domInstance_rigid_body::domTechnique_common::domMass_frame::create(DAE& dae) +{ + domInstance_rigid_body::domTechnique_common::domMass_frameRef ref = new domInstance_rigid_body::domTechnique_common::domMass_frame(dae); + return ref; +} + + +daeMetaElement * +domInstance_rigid_body::domTechnique_common::domMass_frame::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mass_frame" ); + meta->registerClass(domInstance_rigid_body::domTechnique_common::domMass_frame::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "translate" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domMass_frame,elemTranslate_array) ); + mea->setElementType( domTranslate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "rotate" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domMass_frame,elemRotate_array) ); + mea->setElementType( domRotate::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3000 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domInstance_rigid_body::domTechnique_common::domMass_frame,_contents)); + meta->addContentsOrder(daeOffsetOf(domInstance_rigid_body::domTechnique_common::domMass_frame,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domInstance_rigid_body::domTechnique_common::domMass_frame,_CMData), 1); + meta->setElementSize(sizeof(domInstance_rigid_body::domTechnique_common::domMass_frame)); + meta->validate(); + + return meta; +} + +daeElementRef +domInstance_rigid_body::domTechnique_common::domShape::create(DAE& dae) +{ + domInstance_rigid_body::domTechnique_common::domShapeRef ref = new domInstance_rigid_body::domTechnique_common::domShape(dae); + return ref; +} + + +daeMetaElement * +domInstance_rigid_body::domTechnique_common::domShape::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "shape" ); + meta->registerClass(domInstance_rigid_body::domTechnique_common::domShape::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "hollow" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemHollow) ); + mea->setElementType( domInstance_rigid_body::domTechnique_common::domShape::domHollow::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "mass" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemMass) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "density" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemDensity) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 3, 0, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "instance_physics_material" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemInstance_physics_material) ); + mea->setElementType( domInstance_physics_material::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "physics_material" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemPhysics_material) ); + mea->setElementType( domPhysics_material::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm = new daeMetaChoice( meta, cm, 1, 4, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "instance_geometry" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemInstance_geometry) ); + mea->setElementType( domInstance_geometry::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "plane" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemPlane) ); + mea->setElementType( domPlane::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "box" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemBox) ); + mea->setElementType( domBox::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sphere" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemSphere) ); + mea->setElementType( domSphere::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "cylinder" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemCylinder) ); + mea->setElementType( domCylinder::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "tapered_cylinder" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemTapered_cylinder) ); + mea->setElementType( domTapered_cylinder::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "capsule" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemCapsule) ); + mea->setElementType( domCapsule::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "tapered_capsule" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemTapered_capsule) ); + mea->setElementType( domTapered_capsule::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm = new daeMetaChoice( meta, cm, 2, 5, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "translate" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemTranslate_array) ); + mea->setElementType( domTranslate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "rotate" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemRotate_array) ); + mea->setElementType( domRotate::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3006, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3006 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,_contents)); + meta->addContentsOrder(daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domInstance_rigid_body::domTechnique_common::domShape,_CMData), 3); + meta->setElementSize(sizeof(domInstance_rigid_body::domTechnique_common::domShape)); + meta->validate(); + + return meta; +} + +daeElementRef +domInstance_rigid_body::domTechnique_common::domShape::domHollow::create(DAE& dae) +{ + domInstance_rigid_body::domTechnique_common::domShape::domHollowRef ref = new domInstance_rigid_body::domTechnique_common::domShape::domHollow(dae); + return ref; +} + + +daeMetaElement * +domInstance_rigid_body::domTechnique_common::domShape::domHollow::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "hollow" ); + meta->registerClass(domInstance_rigid_body::domTechnique_common::domShape::domHollow::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domInstance_rigid_body::domTechnique_common::domShape::domHollow , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_rigid_body::domTechnique_common::domShape::domHollow , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_rigid_body::domTechnique_common::domShape::domHollow)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInstance_rigid_constraint.cpp b/1.4.0/dom/src/1.4/dom/domInstance_rigid_constraint.cpp new file mode 100644 index 0000000..06ec22c --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInstance_rigid_constraint.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInstance_rigid_constraint.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInstance_rigid_constraint::create(DAE& dae) +{ + domInstance_rigid_constraintRef ref = new domInstance_rigid_constraint(dae); + return ref; +} + + +daeMetaElement * +domInstance_rigid_constraint::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "instance_rigid_constraint" ); + meta->registerClass(domInstance_rigid_constraint::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domInstance_rigid_constraint,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: constraint + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "constraint" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_rigid_constraint , attrConstraint )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_rigid_constraint , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInstance_rigid_constraint , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInstance_rigid_constraint)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domInt_array.cpp b/1.4.0/dom/src/1.4/dom/domInt_array.cpp new file mode 100644 index 0000000..db57dca --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domInt_array.cpp @@ -0,0 +1,114 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domInt_array.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domInt_array::create(DAE& dae) +{ + domInt_arrayRef ref = new domInt_array(dae); + return ref; +} + + +daeMetaElement * +domInt_array::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "int_array" ); + meta->registerClass(domInt_array::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("ListOfInts")); + ma->setOffset( daeOffsetOf( domInt_array , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domInt_array , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domInt_array , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: count + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "count" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domInt_array , attrCount )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: minInclusive + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "minInclusive" ); + ma->setType( dae.getAtomicTypes().get("xsInteger")); + ma->setOffset( daeOffsetOf( domInt_array , attrMinInclusive )); + ma->setContainer( meta ); + ma->setDefaultString( "-2147483648"); + + meta->appendAttribute(ma); + } + + // Add attribute: maxInclusive + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "maxInclusive" ); + ma->setType( dae.getAtomicTypes().get("xsInteger")); + ma->setOffset( daeOffsetOf( domInt_array , attrMaxInclusive )); + ma->setContainer( meta ); + ma->setDefaultString( "2147483647"); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domInt_array)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLibrary_animation_clips.cpp b/1.4.0/dom/src/1.4/dom/domLibrary_animation_clips.cpp new file mode 100644 index 0000000..ded717d --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLibrary_animation_clips.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLibrary_animation_clips.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLibrary_animation_clips::create(DAE& dae) +{ + domLibrary_animation_clipsRef ref = new domLibrary_animation_clips(dae); + return ref; +} + + +daeMetaElement * +domLibrary_animation_clips::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "library_animation_clips" ); + meta->registerClass(domLibrary_animation_clips::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLibrary_animation_clips,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "animation_clip" ); + mea->setOffset( daeOffsetOf(domLibrary_animation_clips,elemAnimation_clip_array) ); + mea->setElementType( domAnimation_clip::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLibrary_animation_clips,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLibrary_animation_clips , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLibrary_animation_clips , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLibrary_animation_clips)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLibrary_animations.cpp b/1.4.0/dom/src/1.4/dom/domLibrary_animations.cpp new file mode 100644 index 0000000..d58e4c8 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLibrary_animations.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLibrary_animations.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLibrary_animations::create(DAE& dae) +{ + domLibrary_animationsRef ref = new domLibrary_animations(dae); + return ref; +} + + +daeMetaElement * +domLibrary_animations::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "library_animations" ); + meta->registerClass(domLibrary_animations::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLibrary_animations,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "animation" ); + mea->setOffset( daeOffsetOf(domLibrary_animations,elemAnimation_array) ); + mea->setElementType( domAnimation::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLibrary_animations,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLibrary_animations , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLibrary_animations , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLibrary_animations)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLibrary_cameras.cpp b/1.4.0/dom/src/1.4/dom/domLibrary_cameras.cpp new file mode 100644 index 0000000..cfdf0d6 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLibrary_cameras.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLibrary_cameras.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLibrary_cameras::create(DAE& dae) +{ + domLibrary_camerasRef ref = new domLibrary_cameras(dae); + return ref; +} + + +daeMetaElement * +domLibrary_cameras::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "library_cameras" ); + meta->registerClass(domLibrary_cameras::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLibrary_cameras,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "camera" ); + mea->setOffset( daeOffsetOf(domLibrary_cameras,elemCamera_array) ); + mea->setElementType( domCamera::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLibrary_cameras,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLibrary_cameras , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLibrary_cameras , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLibrary_cameras)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLibrary_controllers.cpp b/1.4.0/dom/src/1.4/dom/domLibrary_controllers.cpp new file mode 100644 index 0000000..87f7aaa --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLibrary_controllers.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLibrary_controllers.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLibrary_controllers::create(DAE& dae) +{ + domLibrary_controllersRef ref = new domLibrary_controllers(dae); + return ref; +} + + +daeMetaElement * +domLibrary_controllers::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "library_controllers" ); + meta->registerClass(domLibrary_controllers::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLibrary_controllers,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "controller" ); + mea->setOffset( daeOffsetOf(domLibrary_controllers,elemController_array) ); + mea->setElementType( domController::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLibrary_controllers,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLibrary_controllers , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLibrary_controllers , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLibrary_controllers)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLibrary_effects.cpp b/1.4.0/dom/src/1.4/dom/domLibrary_effects.cpp new file mode 100644 index 0000000..084ed7a --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLibrary_effects.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLibrary_effects.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLibrary_effects::create(DAE& dae) +{ + domLibrary_effectsRef ref = new domLibrary_effects(dae); + return ref; +} + + +daeMetaElement * +domLibrary_effects::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "library_effects" ); + meta->registerClass(domLibrary_effects::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLibrary_effects,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "effect" ); + mea->setOffset( daeOffsetOf(domLibrary_effects,elemEffect_array) ); + mea->setElementType( domEffect::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLibrary_effects,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLibrary_effects , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLibrary_effects , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLibrary_effects)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLibrary_force_fields.cpp b/1.4.0/dom/src/1.4/dom/domLibrary_force_fields.cpp new file mode 100644 index 0000000..6b9c250 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLibrary_force_fields.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLibrary_force_fields.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLibrary_force_fields::create(DAE& dae) +{ + domLibrary_force_fieldsRef ref = new domLibrary_force_fields(dae); + return ref; +} + + +daeMetaElement * +domLibrary_force_fields::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "library_force_fields" ); + meta->registerClass(domLibrary_force_fields::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLibrary_force_fields,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "force_field" ); + mea->setOffset( daeOffsetOf(domLibrary_force_fields,elemForce_field_array) ); + mea->setElementType( domForce_field::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLibrary_force_fields,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLibrary_force_fields , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLibrary_force_fields , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLibrary_force_fields)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLibrary_geometries.cpp b/1.4.0/dom/src/1.4/dom/domLibrary_geometries.cpp new file mode 100644 index 0000000..119faa8 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLibrary_geometries.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLibrary_geometries.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLibrary_geometries::create(DAE& dae) +{ + domLibrary_geometriesRef ref = new domLibrary_geometries(dae); + return ref; +} + + +daeMetaElement * +domLibrary_geometries::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "library_geometries" ); + meta->registerClass(domLibrary_geometries::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLibrary_geometries,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "geometry" ); + mea->setOffset( daeOffsetOf(domLibrary_geometries,elemGeometry_array) ); + mea->setElementType( domGeometry::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLibrary_geometries,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLibrary_geometries , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLibrary_geometries , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLibrary_geometries)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLibrary_images.cpp b/1.4.0/dom/src/1.4/dom/domLibrary_images.cpp new file mode 100644 index 0000000..5208d21 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLibrary_images.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLibrary_images.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLibrary_images::create(DAE& dae) +{ + domLibrary_imagesRef ref = new domLibrary_images(dae); + return ref; +} + + +daeMetaElement * +domLibrary_images::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "library_images" ); + meta->registerClass(domLibrary_images::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLibrary_images,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "image" ); + mea->setOffset( daeOffsetOf(domLibrary_images,elemImage_array) ); + mea->setElementType( domImage::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLibrary_images,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLibrary_images , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLibrary_images , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLibrary_images)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLibrary_lights.cpp b/1.4.0/dom/src/1.4/dom/domLibrary_lights.cpp new file mode 100644 index 0000000..7d9c81f --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLibrary_lights.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLibrary_lights.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLibrary_lights::create(DAE& dae) +{ + domLibrary_lightsRef ref = new domLibrary_lights(dae); + return ref; +} + + +daeMetaElement * +domLibrary_lights::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "library_lights" ); + meta->registerClass(domLibrary_lights::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLibrary_lights,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "light" ); + mea->setOffset( daeOffsetOf(domLibrary_lights,elemLight_array) ); + mea->setElementType( domLight::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLibrary_lights,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLibrary_lights , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLibrary_lights , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLibrary_lights)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLibrary_materials.cpp b/1.4.0/dom/src/1.4/dom/domLibrary_materials.cpp new file mode 100644 index 0000000..89a5f21 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLibrary_materials.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLibrary_materials.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLibrary_materials::create(DAE& dae) +{ + domLibrary_materialsRef ref = new domLibrary_materials(dae); + return ref; +} + + +daeMetaElement * +domLibrary_materials::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "library_materials" ); + meta->registerClass(domLibrary_materials::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLibrary_materials,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "material" ); + mea->setOffset( daeOffsetOf(domLibrary_materials,elemMaterial_array) ); + mea->setElementType( domMaterial::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLibrary_materials,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLibrary_materials , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLibrary_materials , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLibrary_materials)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLibrary_nodes.cpp b/1.4.0/dom/src/1.4/dom/domLibrary_nodes.cpp new file mode 100644 index 0000000..382070a --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLibrary_nodes.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLibrary_nodes.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLibrary_nodes::create(DAE& dae) +{ + domLibrary_nodesRef ref = new domLibrary_nodes(dae); + return ref; +} + + +daeMetaElement * +domLibrary_nodes::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "library_nodes" ); + meta->registerClass(domLibrary_nodes::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLibrary_nodes,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "node" ); + mea->setOffset( daeOffsetOf(domLibrary_nodes,elemNode_array) ); + mea->setElementType( domNode::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLibrary_nodes,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLibrary_nodes , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLibrary_nodes , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLibrary_nodes)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLibrary_physics_materials.cpp b/1.4.0/dom/src/1.4/dom/domLibrary_physics_materials.cpp new file mode 100644 index 0000000..ca72d97 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLibrary_physics_materials.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLibrary_physics_materials.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLibrary_physics_materials::create(DAE& dae) +{ + domLibrary_physics_materialsRef ref = new domLibrary_physics_materials(dae); + return ref; +} + + +daeMetaElement * +domLibrary_physics_materials::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "library_physics_materials" ); + meta->registerClass(domLibrary_physics_materials::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLibrary_physics_materials,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "physics_material" ); + mea->setOffset( daeOffsetOf(domLibrary_physics_materials,elemPhysics_material_array) ); + mea->setElementType( domPhysics_material::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLibrary_physics_materials,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLibrary_physics_materials , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLibrary_physics_materials , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLibrary_physics_materials)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLibrary_physics_models.cpp b/1.4.0/dom/src/1.4/dom/domLibrary_physics_models.cpp new file mode 100644 index 0000000..0b3af71 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLibrary_physics_models.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLibrary_physics_models.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLibrary_physics_models::create(DAE& dae) +{ + domLibrary_physics_modelsRef ref = new domLibrary_physics_models(dae); + return ref; +} + + +daeMetaElement * +domLibrary_physics_models::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "library_physics_models" ); + meta->registerClass(domLibrary_physics_models::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLibrary_physics_models,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "physics_model" ); + mea->setOffset( daeOffsetOf(domLibrary_physics_models,elemPhysics_model_array) ); + mea->setElementType( domPhysics_model::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLibrary_physics_models,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLibrary_physics_models , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLibrary_physics_models , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLibrary_physics_models)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLibrary_physics_scenes.cpp b/1.4.0/dom/src/1.4/dom/domLibrary_physics_scenes.cpp new file mode 100644 index 0000000..678011f --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLibrary_physics_scenes.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLibrary_physics_scenes.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLibrary_physics_scenes::create(DAE& dae) +{ + domLibrary_physics_scenesRef ref = new domLibrary_physics_scenes(dae); + return ref; +} + + +daeMetaElement * +domLibrary_physics_scenes::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "library_physics_scenes" ); + meta->registerClass(domLibrary_physics_scenes::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLibrary_physics_scenes,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "physics_scene" ); + mea->setOffset( daeOffsetOf(domLibrary_physics_scenes,elemPhysics_scene_array) ); + mea->setElementType( domPhysics_scene::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLibrary_physics_scenes,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLibrary_physics_scenes , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLibrary_physics_scenes , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLibrary_physics_scenes)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLibrary_visual_scenes.cpp b/1.4.0/dom/src/1.4/dom/domLibrary_visual_scenes.cpp new file mode 100644 index 0000000..eff702c --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLibrary_visual_scenes.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLibrary_visual_scenes.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLibrary_visual_scenes::create(DAE& dae) +{ + domLibrary_visual_scenesRef ref = new domLibrary_visual_scenes(dae); + return ref; +} + + +daeMetaElement * +domLibrary_visual_scenes::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "library_visual_scenes" ); + meta->registerClass(domLibrary_visual_scenes::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLibrary_visual_scenes,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "visual_scene" ); + mea->setOffset( daeOffsetOf(domLibrary_visual_scenes,elemVisual_scene_array) ); + mea->setElementType( domVisual_scene::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLibrary_visual_scenes,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLibrary_visual_scenes , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLibrary_visual_scenes , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLibrary_visual_scenes)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLight.cpp b/1.4.0/dom/src/1.4/dom/domLight.cpp new file mode 100644 index 0000000..f777725 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLight.cpp @@ -0,0 +1,364 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLight.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLight::create(DAE& dae) +{ + domLightRef ref = new domLight(dae); + return ref; +} + + +daeMetaElement * +domLight::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "light" ); + meta->registerClass(domLight::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domLight,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "technique_common" ); + mea->setOffset( daeOffsetOf(domLight,elemTechnique_common) ); + mea->setElementType( domLight::domTechnique_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domLight,elemTechnique_array) ); + mea->setElementType( domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLight,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domLight , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLight , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLight)); + meta->validate(); + + return meta; +} + +daeElementRef +domLight::domTechnique_common::create(DAE& dae) +{ + domLight::domTechnique_commonRef ref = new domLight::domTechnique_common(dae); + return ref; +} + + +daeMetaElement * +domLight::domTechnique_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "technique_common" ); + meta->registerClass(domLight::domTechnique_common::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "ambient" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common,elemAmbient) ); + mea->setElementType( domLight::domTechnique_common::domAmbient::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "directional" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common,elemDirectional) ); + mea->setElementType( domLight::domTechnique_common::domDirectional::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "point" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common,elemPoint) ); + mea->setElementType( domLight::domTechnique_common::domPoint::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "spot" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common,elemSpot) ); + mea->setElementType( domLight::domTechnique_common::domSpot::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domLight::domTechnique_common,_contents)); + meta->addContentsOrder(daeOffsetOf(domLight::domTechnique_common,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domLight::domTechnique_common,_CMData), 1); + meta->setElementSize(sizeof(domLight::domTechnique_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domLight::domTechnique_common::domAmbient::create(DAE& dae) +{ + domLight::domTechnique_common::domAmbientRef ref = new domLight::domTechnique_common::domAmbient(dae); + return ref; +} + + +daeMetaElement * +domLight::domTechnique_common::domAmbient::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "ambient" ); + meta->registerClass(domLight::domTechnique_common::domAmbient::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "color" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common::domAmbient,elemColor) ); + mea->setElementType( domTargetableFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domLight::domTechnique_common::domAmbient)); + meta->validate(); + + return meta; +} + +daeElementRef +domLight::domTechnique_common::domDirectional::create(DAE& dae) +{ + domLight::domTechnique_common::domDirectionalRef ref = new domLight::domTechnique_common::domDirectional(dae); + return ref; +} + + +daeMetaElement * +domLight::domTechnique_common::domDirectional::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "directional" ); + meta->registerClass(domLight::domTechnique_common::domDirectional::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "color" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common::domDirectional,elemColor) ); + mea->setElementType( domTargetableFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domLight::domTechnique_common::domDirectional)); + meta->validate(); + + return meta; +} + +daeElementRef +domLight::domTechnique_common::domPoint::create(DAE& dae) +{ + domLight::domTechnique_common::domPointRef ref = new domLight::domTechnique_common::domPoint(dae); + return ref; +} + + +daeMetaElement * +domLight::domTechnique_common::domPoint::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "point" ); + meta->registerClass(domLight::domTechnique_common::domPoint::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "color" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common::domPoint,elemColor) ); + mea->setElementType( domTargetableFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "constant_attenuation" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common::domPoint,elemConstant_attenuation) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "linear_attenuation" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common::domPoint,elemLinear_attenuation) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "quadratic_attenuation" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common::domPoint,elemQuadratic_attenuation) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domLight::domTechnique_common::domPoint)); + meta->validate(); + + return meta; +} + +daeElementRef +domLight::domTechnique_common::domSpot::create(DAE& dae) +{ + domLight::domTechnique_common::domSpotRef ref = new domLight::domTechnique_common::domSpot(dae); + return ref; +} + + +daeMetaElement * +domLight::domTechnique_common::domSpot::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "spot" ); + meta->registerClass(domLight::domTechnique_common::domSpot::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "color" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common::domSpot,elemColor) ); + mea->setElementType( domTargetableFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "constant_attenuation" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common::domSpot,elemConstant_attenuation) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "linear_attenuation" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common::domSpot,elemLinear_attenuation) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "quadratic_attenuation" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common::domSpot,elemQuadratic_attenuation) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "falloff_angle" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common::domSpot,elemFalloff_angle) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "falloff_exponent" ); + mea->setOffset( daeOffsetOf(domLight::domTechnique_common::domSpot,elemFalloff_exponent) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 5 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domLight::domTechnique_common::domSpot)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLines.cpp b/1.4.0/dom/src/1.4/dom/domLines.cpp new file mode 100644 index 0000000..33934a8 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLines.cpp @@ -0,0 +1,105 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLines.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLines::create(DAE& dae) +{ + domLinesRef ref = new domLines(dae); + return ref; +} + + +daeMetaElement * +domLines::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "lines" ); + meta->registerClass(domLines::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "input" ); + mea->setOffset( daeOffsetOf(domLines,elemInput_array) ); + mea->setElementType( domInputLocalOffset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "p" ); + mea->setOffset( daeOffsetOf(domLines,elemP) ); + mea->setElementType( domP::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLines,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLines , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: count + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "count" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domLines , attrCount )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: material + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "material" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLines , attrMaterial )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLines)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLinestrips.cpp b/1.4.0/dom/src/1.4/dom/domLinestrips.cpp new file mode 100644 index 0000000..a058d7d --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLinestrips.cpp @@ -0,0 +1,105 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLinestrips.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLinestrips::create(DAE& dae) +{ + domLinestripsRef ref = new domLinestrips(dae); + return ref; +} + + +daeMetaElement * +domLinestrips::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "linestrips" ); + meta->registerClass(domLinestrips::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "input" ); + mea->setOffset( daeOffsetOf(domLinestrips,elemInput_array) ); + mea->setElementType( domInputLocalOffset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "p" ); + mea->setOffset( daeOffsetOf(domLinestrips,elemP_array) ); + mea->setElementType( domP::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domLinestrips,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLinestrips , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: count + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "count" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domLinestrips , attrCount )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: material + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "material" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLinestrips , attrMaterial )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLinestrips)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domLookat.cpp b/1.4.0/dom/src/1.4/dom/domLookat.cpp new file mode 100644 index 0000000..345cf1b --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domLookat.cpp @@ -0,0 +1,67 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domLookat.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domLookat::create(DAE& dae) +{ + domLookatRef ref = new domLookat(dae); + return ref; +} + + +daeMetaElement * +domLookat::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "lookat" ); + meta->registerClass(domLookat::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3x3")); + ma->setOffset( daeOffsetOf( domLookat , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domLookat , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domLookat)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domMaterial.cpp b/1.4.0/dom/src/1.4/dom/domMaterial.cpp new file mode 100644 index 0000000..1cde142 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domMaterial.cpp @@ -0,0 +1,93 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domMaterial.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domMaterial::create(DAE& dae) +{ + domMaterialRef ref = new domMaterial(dae); + return ref; +} + + +daeMetaElement * +domMaterial::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "material" ); + meta->registerClass(domMaterial::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domMaterial,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "instance_effect" ); + mea->setOffset( daeOffsetOf(domMaterial,elemInstance_effect) ); + mea->setElementType( domInstance_effect::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domMaterial,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domMaterial , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domMaterial , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domMaterial)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domMatrix.cpp b/1.4.0/dom/src/1.4/dom/domMatrix.cpp new file mode 100644 index 0000000..f269a2b --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domMatrix.cpp @@ -0,0 +1,67 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domMatrix.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domMatrix::create(DAE& dae) +{ + domMatrixRef ref = new domMatrix(dae); + return ref; +} + + +daeMetaElement * +domMatrix::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "matrix" ); + meta->registerClass(domMatrix::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4x4")); + ma->setOffset( daeOffsetOf( domMatrix , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domMatrix , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domMatrix)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domMesh.cpp b/1.4.0/dom/src/1.4/dom/domMesh.cpp new file mode 100644 index 0000000..a8b593e --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domMesh.cpp @@ -0,0 +1,123 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domMesh.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domMesh::create(DAE& dae) +{ + domMeshRef ref = new domMesh(dae); + return ref; +} + + +daeMetaElement * +domMesh::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mesh" ); + meta->registerClass(domMesh::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, -1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domMesh,elemSource_array) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "vertices" ); + mea->setOffset( daeOffsetOf(domMesh,elemVertices) ); + mea->setElementType( domVertices::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 2, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "lines" ); + mea->setOffset( daeOffsetOf(domMesh,elemLines_array) ); + mea->setElementType( domLines::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "linestrips" ); + mea->setOffset( daeOffsetOf(domMesh,elemLinestrips_array) ); + mea->setElementType( domLinestrips::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "polygons" ); + mea->setOffset( daeOffsetOf(domMesh,elemPolygons_array) ); + mea->setElementType( domPolygons::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "polylist" ); + mea->setOffset( daeOffsetOf(domMesh,elemPolylist_array) ); + mea->setElementType( domPolylist::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "triangles" ); + mea->setOffset( daeOffsetOf(domMesh,elemTriangles_array) ); + mea->setElementType( domTriangles::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "trifans" ); + mea->setOffset( daeOffsetOf(domMesh,elemTrifans_array) ); + mea->setElementType( domTrifans::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "tristrips" ); + mea->setOffset( daeOffsetOf(domMesh,elemTristrips_array) ); + mea->setElementType( domTristrips::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3003, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domMesh,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3003 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domMesh,_contents)); + meta->addContentsOrder(daeOffsetOf(domMesh,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domMesh,_CMData), 1); + meta->setElementSize(sizeof(domMesh)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domMorph.cpp b/1.4.0/dom/src/1.4/dom/domMorph.cpp new file mode 100644 index 0000000..cccd055 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domMorph.cpp @@ -0,0 +1,140 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domMorph.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domMorph::create(DAE& dae) +{ + domMorphRef ref = new domMorph(dae); + return ref; +} + + +daeMetaElement * +domMorph::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "morph" ); + meta->registerClass(domMorph::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 2, -1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domMorph,elemSource_array) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "targets" ); + mea->setOffset( daeOffsetOf(domMorph,elemTargets) ); + mea->setElementType( domMorph::domTargets::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domMorph,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: method + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "method" ); + ma->setType( dae.getAtomicTypes().get("MorphMethodType")); + ma->setOffset( daeOffsetOf( domMorph , attrMethod )); + ma->setContainer( meta ); + ma->setDefaultString( "NORMALIZED"); + + meta->appendAttribute(ma); + } + + // Add attribute: source + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "source" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domMorph , attrSource )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domMorph)); + meta->validate(); + + return meta; +} + +daeElementRef +domMorph::domTargets::create(DAE& dae) +{ + domMorph::domTargetsRef ref = new domMorph::domTargets(dae); + return ref; +} + + +daeMetaElement * +domMorph::domTargets::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "targets" ); + meta->registerClass(domMorph::domTargets::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 2, -1 ); + mea->setName( "input" ); + mea->setOffset( daeOffsetOf(domMorph::domTargets,elemInput_array) ); + mea->setElementType( domInputLocal::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domMorph::domTargets,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domMorph::domTargets)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domName_array.cpp b/1.4.0/dom/src/1.4/dom/domName_array.cpp new file mode 100644 index 0000000..5d7efe7 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domName_array.cpp @@ -0,0 +1,90 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domName_array.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domName_array::create(DAE& dae) +{ + domName_arrayRef ref = new domName_array(dae); + return ref; +} + + +daeMetaElement * +domName_array::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "Name_array" ); + meta->registerClass(domName_array::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("ListOfNames")); + ma->setOffset( daeOffsetOf( domName_array , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domName_array , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domName_array , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: count + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "count" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domName_array , attrCount )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domName_array)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domNode.cpp b/1.4.0/dom/src/1.4/dom/domNode.cpp new file mode 100644 index 0000000..bc71d8a --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domNode.cpp @@ -0,0 +1,203 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domNode.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domNode::create(DAE& dae) +{ + domNodeRef ref = new domNode(dae); + return ref; +} + + +daeMetaElement * +domNode::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "node" ); + meta->registerClass(domNode::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domNode,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "lookat" ); + mea->setOffset( daeOffsetOf(domNode,elemLookat_array) ); + mea->setElementType( domLookat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "matrix" ); + mea->setOffset( daeOffsetOf(domNode,elemMatrix_array) ); + mea->setElementType( domMatrix::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "rotate" ); + mea->setOffset( daeOffsetOf(domNode,elemRotate_array) ); + mea->setElementType( domRotate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "scale" ); + mea->setOffset( daeOffsetOf(domNode,elemScale_array) ); + mea->setElementType( domScale::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "skew" ); + mea->setOffset( daeOffsetOf(domNode,elemSkew_array) ); + mea->setElementType( domSkew::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "translate" ); + mea->setOffset( daeOffsetOf(domNode,elemTranslate_array) ); + mea->setElementType( domTranslate::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3002, 0, -1 ); + mea->setName( "instance_camera" ); + mea->setOffset( daeOffsetOf(domNode,elemInstance_camera_array) ); + mea->setElementType( domInstance_camera::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3003, 0, -1 ); + mea->setName( "instance_controller" ); + mea->setOffset( daeOffsetOf(domNode,elemInstance_controller_array) ); + mea->setElementType( domInstance_controller::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3004, 0, -1 ); + mea->setName( "instance_geometry" ); + mea->setOffset( daeOffsetOf(domNode,elemInstance_geometry_array) ); + mea->setElementType( domInstance_geometry::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3005, 0, -1 ); + mea->setName( "instance_light" ); + mea->setOffset( daeOffsetOf(domNode,elemInstance_light_array) ); + mea->setElementType( domInstance_light::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3006, 0, -1 ); + mea->setName( "instance_node" ); + mea->setOffset( daeOffsetOf(domNode,elemInstance_node_array) ); + mea->setElementType( domInstance_node::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3007, 0, -1 ); + mea->setName( "node" ); + mea->setOffset( daeOffsetOf(domNode,elemNode_array) ); + mea->setElementType( domNode::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3008, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domNode,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3008 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domNode,_contents)); + meta->addContentsOrder(daeOffsetOf(domNode,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domNode,_CMData), 1); + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domNode , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domNode , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domNode , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: type + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "type" ); + ma->setType( dae.getAtomicTypes().get("NodeType")); + ma->setOffset( daeOffsetOf( domNode , attrType )); + ma->setContainer( meta ); + ma->setDefaultString( "NODE"); + + meta->appendAttribute(ma); + } + + // Add attribute: layer + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "layer" ); + ma->setType( dae.getAtomicTypes().get("ListOfNames")); + ma->setOffset( daeOffsetOf( domNode , attrLayer )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domNode)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domP.cpp b/1.4.0/dom/src/1.4/dom/domP.cpp new file mode 100644 index 0000000..4d4353f --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domP.cpp @@ -0,0 +1,56 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domP.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domP::create(DAE& dae) +{ + domPRef ref = new domP(dae); + return ref; +} + + +daeMetaElement * +domP::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "p" ); + meta->registerClass(domP::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("ListOfUInts")); + ma->setOffset( daeOffsetOf( domP , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domP)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domParam.cpp b/1.4.0/dom/src/1.4/dom/domParam.cpp new file mode 100644 index 0000000..f838e0a --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domParam.cpp @@ -0,0 +1,101 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domParam.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domParam::create(DAE& dae) +{ + domParamRef ref = new domParam(dae); + return ref; +} + + +daeMetaElement * +domParam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "param" ); + meta->registerClass(domParam::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domParam , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domParam , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domParam , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: semantic + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "semantic" ); + ma->setType( dae.getAtomicTypes().get("xsNMTOKEN")); + ma->setOffset( daeOffsetOf( domParam , attrSemantic )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: type + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "type" ); + ma->setType( dae.getAtomicTypes().get("xsNMTOKEN")); + ma->setOffset( daeOffsetOf( domParam , attrType )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domParam)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domPhysics_material.cpp b/1.4.0/dom/src/1.4/dom/domPhysics_material.cpp new file mode 100644 index 0000000..cfd572d --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domPhysics_material.cpp @@ -0,0 +1,150 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domPhysics_material.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domPhysics_material::create(DAE& dae) +{ + domPhysics_materialRef ref = new domPhysics_material(dae); + return ref; +} + + +daeMetaElement * +domPhysics_material::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "physics_material" ); + meta->registerClass(domPhysics_material::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domPhysics_material,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "technique_common" ); + mea->setOffset( daeOffsetOf(domPhysics_material,elemTechnique_common) ); + mea->setElementType( domPhysics_material::domTechnique_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domPhysics_material,elemTechnique_array) ); + mea->setElementType( domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domPhysics_material,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domPhysics_material , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domPhysics_material , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domPhysics_material)); + meta->validate(); + + return meta; +} + +daeElementRef +domPhysics_material::domTechnique_common::create(DAE& dae) +{ + domPhysics_material::domTechnique_commonRef ref = new domPhysics_material::domTechnique_common(dae); + return ref; +} + + +daeMetaElement * +domPhysics_material::domTechnique_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "technique_common" ); + meta->registerClass(domPhysics_material::domTechnique_common::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "dynamic_friction" ); + mea->setOffset( daeOffsetOf(domPhysics_material::domTechnique_common,elemDynamic_friction) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "restitution" ); + mea->setOffset( daeOffsetOf(domPhysics_material::domTechnique_common,elemRestitution) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "static_friction" ); + mea->setOffset( daeOffsetOf(domPhysics_material::domTechnique_common,elemStatic_friction) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domPhysics_material::domTechnique_common)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domPhysics_model.cpp b/1.4.0/dom/src/1.4/dom/domPhysics_model.cpp new file mode 100644 index 0000000..426fc04 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domPhysics_model.cpp @@ -0,0 +1,105 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domPhysics_model.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domPhysics_model::create(DAE& dae) +{ + domPhysics_modelRef ref = new domPhysics_model(dae); + return ref; +} + + +daeMetaElement * +domPhysics_model::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "physics_model" ); + meta->registerClass(domPhysics_model::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domPhysics_model,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "rigid_body" ); + mea->setOffset( daeOffsetOf(domPhysics_model,elemRigid_body_array) ); + mea->setElementType( domRigid_body::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "rigid_constraint" ); + mea->setOffset( daeOffsetOf(domPhysics_model,elemRigid_constraint_array) ); + mea->setElementType( domRigid_constraint::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "instance_physics_model" ); + mea->setOffset( daeOffsetOf(domPhysics_model,elemInstance_physics_model_array) ); + mea->setElementType( domInstance_physics_model::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 4, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domPhysics_model,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 4 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domPhysics_model , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domPhysics_model , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domPhysics_model)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domPhysics_scene.cpp b/1.4.0/dom/src/1.4/dom/domPhysics_scene.cpp new file mode 100644 index 0000000..50a651d --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domPhysics_scene.cpp @@ -0,0 +1,156 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domPhysics_scene.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domPhysics_scene::create(DAE& dae) +{ + domPhysics_sceneRef ref = new domPhysics_scene(dae); + return ref; +} + + +daeMetaElement * +domPhysics_scene::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "physics_scene" ); + meta->registerClass(domPhysics_scene::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domPhysics_scene,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "instance_force_field" ); + mea->setOffset( daeOffsetOf(domPhysics_scene,elemInstance_force_field_array) ); + mea->setElementType( domInstance_force_field::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "instance_physics_model" ); + mea->setOffset( daeOffsetOf(domPhysics_scene,elemInstance_physics_model_array) ); + mea->setElementType( domInstance_physics_model::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 1, 1 ); + mea->setName( "technique_common" ); + mea->setOffset( daeOffsetOf(domPhysics_scene,elemTechnique_common) ); + mea->setElementType( domPhysics_scene::domTechnique_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 4, 0, -1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domPhysics_scene,elemTechnique_array) ); + mea->setElementType( domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 5, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domPhysics_scene,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 5 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domPhysics_scene , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domPhysics_scene , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domPhysics_scene)); + meta->validate(); + + return meta; +} + +daeElementRef +domPhysics_scene::domTechnique_common::create(DAE& dae) +{ + domPhysics_scene::domTechnique_commonRef ref = new domPhysics_scene::domTechnique_common(dae); + return ref; +} + + +daeMetaElement * +domPhysics_scene::domTechnique_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "technique_common" ); + meta->registerClass(domPhysics_scene::domTechnique_common::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "gravity" ); + mea->setOffset( daeOffsetOf(domPhysics_scene::domTechnique_common,elemGravity) ); + mea->setElementType( domTargetableFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "time_step" ); + mea->setOffset( daeOffsetOf(domPhysics_scene::domTechnique_common,elemTime_step) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domPhysics_scene::domTechnique_common)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domPlane.cpp b/1.4.0/dom/src/1.4/dom/domPlane.cpp new file mode 100644 index 0000000..d5a244c --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domPlane.cpp @@ -0,0 +1,101 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domPlane.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domPlane::create(DAE& dae) +{ + domPlaneRef ref = new domPlane(dae); + return ref; +} + + +daeMetaElement * +domPlane::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "plane" ); + meta->registerClass(domPlane::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "equation" ); + mea->setOffset( daeOffsetOf(domPlane,elemEquation) ); + mea->setElementType( domPlane::domEquation::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domPlane,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domPlane)); + meta->validate(); + + return meta; +} + +daeElementRef +domPlane::domEquation::create(DAE& dae) +{ + domPlane::domEquationRef ref = new domPlane::domEquation(dae); + return ref; +} + + +daeMetaElement * +domPlane::domEquation::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "equation" ); + meta->registerClass(domPlane::domEquation::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domPlane::domEquation , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domPlane::domEquation)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domPolygons.cpp b/1.4.0/dom/src/1.4/dom/domPolygons.cpp new file mode 100644 index 0000000..754a006 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domPolygons.cpp @@ -0,0 +1,202 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domPolygons.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domPolygons::create(DAE& dae) +{ + domPolygonsRef ref = new domPolygons(dae); + return ref; +} + + +daeMetaElement * +domPolygons::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "polygons" ); + meta->registerClass(domPolygons::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "input" ); + mea->setOffset( daeOffsetOf(domPolygons,elemInput_array) ); + mea->setElementType( domInputLocalOffset::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "p" ); + mea->setOffset( daeOffsetOf(domPolygons,elemP_array) ); + mea->setElementType( domP::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "ph" ); + mea->setOffset( daeOffsetOf(domPolygons,elemPh_array) ); + mea->setElementType( domPolygons::domPh::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3002, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domPolygons,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3002 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domPolygons,_contents)); + meta->addContentsOrder(daeOffsetOf(domPolygons,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domPolygons,_CMData), 1); + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domPolygons , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: count + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "count" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domPolygons , attrCount )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: material + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "material" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domPolygons , attrMaterial )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domPolygons)); + meta->validate(); + + return meta; +} + +daeElementRef +domPolygons::domPh::create(DAE& dae) +{ + domPolygons::domPhRef ref = new domPolygons::domPh(dae); + return ref; +} + + +daeMetaElement * +domPolygons::domPh::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "ph" ); + meta->registerClass(domPolygons::domPh::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "p" ); + mea->setOffset( daeOffsetOf(domPolygons::domPh,elemP) ); + mea->setElementType( domP::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "h" ); + mea->setOffset( daeOffsetOf(domPolygons::domPh,elemH_array) ); + mea->setElementType( domPolygons::domPh::domH::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domPolygons::domPh)); + meta->validate(); + + return meta; +} + +daeElementRef +domPolygons::domPh::domH::create(DAE& dae) +{ + domPolygons::domPh::domHRef ref = new domPolygons::domPh::domH(dae); + return ref; +} + + +daeMetaElement * +domPolygons::domPh::domH::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "h" ); + meta->registerClass(domPolygons::domPh::domH::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("ListOfUInts")); + ma->setOffset( daeOffsetOf( domPolygons::domPh::domH , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domPolygons::domPh::domH)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domPolylist.cpp b/1.4.0/dom/src/1.4/dom/domPolylist.cpp new file mode 100644 index 0000000..a09ee2c --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domPolylist.cpp @@ -0,0 +1,147 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domPolylist.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domPolylist::create(DAE& dae) +{ + domPolylistRef ref = new domPolylist(dae); + return ref; +} + + +daeMetaElement * +domPolylist::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "polylist" ); + meta->registerClass(domPolylist::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "input" ); + mea->setOffset( daeOffsetOf(domPolylist,elemInput_array) ); + mea->setElementType( domInputLocalOffset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "vcount" ); + mea->setOffset( daeOffsetOf(domPolylist,elemVcount) ); + mea->setElementType( domPolylist::domVcount::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "p" ); + mea->setOffset( daeOffsetOf(domPolylist,elemP) ); + mea->setElementType( domP::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domPolylist,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domPolylist , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: count + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "count" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domPolylist , attrCount )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: material + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "material" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domPolylist , attrMaterial )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domPolylist)); + meta->validate(); + + return meta; +} + +daeElementRef +domPolylist::domVcount::create(DAE& dae) +{ + domPolylist::domVcountRef ref = new domPolylist::domVcount(dae); + return ref; +} + + +daeMetaElement * +domPolylist::domVcount::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "vcount" ); + meta->registerClass(domPolylist::domVcount::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("ListOfUInts")); + ma->setOffset( daeOffsetOf( domPolylist::domVcount , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domPolylist::domVcount)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domProfile_CG.cpp b/1.4.0/dom/src/1.4/dom/domProfile_CG.cpp new file mode 100644 index 0000000..942c3a7 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domProfile_CG.cpp @@ -0,0 +1,719 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domProfile_CG.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domProfile_CG::create(DAE& dae) +{ + domProfile_CGRef ref = new domProfile_CG(dae); + return ref; +} + + +daeMetaElement * +domProfile_CG::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "profile_CG" ); + meta->registerClass(domProfile_CG::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domProfile_CG,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "code" ); + mea->setOffset( daeOffsetOf(domProfile_CG,elemCode_array) ); + mea->setElementType( domFx_code_profile::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "include" ); + mea->setOffset( daeOffsetOf(domProfile_CG,elemInclude_array) ); + mea->setElementType( domFx_include_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm = new daeMetaChoice( meta, cm, 1, 3002, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "image" ); + mea->setOffset( daeOffsetOf(domProfile_CG,elemImage_array) ); + mea->setElementType( domImage::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "newparam" ); + mea->setOffset( daeOffsetOf(domProfile_CG,elemNewparam_array) ); + mea->setElementType( domCg_newparam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 6003, 1, -1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domProfile_CG,elemTechnique_array) ); + mea->setElementType( domProfile_CG::domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 6004, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domProfile_CG,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 6004 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domProfile_CG,_contents)); + meta->addContentsOrder(daeOffsetOf(domProfile_CG,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domProfile_CG,_CMData), 2); + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domProfile_CG , attrId )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: platform + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "platform" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_CG , attrPlatform )); + ma->setContainer( meta ); + ma->setDefaultString( "PC"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_CG)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_CG::domTechnique::create(DAE& dae) +{ + domProfile_CG::domTechniqueRef ref = new domProfile_CG::domTechnique(dae); + return ref; +} + + +daeMetaElement * +domProfile_CG::domTechnique::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "technique" ); + meta->registerClass(domProfile_CG::domTechnique::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 2, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "code" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique,elemCode_array) ); + mea->setElementType( domFx_code_profile::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "include" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique,elemInclude_array) ); + mea->setElementType( domFx_include_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm = new daeMetaChoice( meta, cm, 1, 3003, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "image" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique,elemImage_array) ); + mea->setElementType( domImage::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "newparam" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique,elemNewparam_array) ); + mea->setElementType( domCg_newparam::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "setparam" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique,elemSetparam_array) ); + mea->setElementType( domCg_setparam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 6004, 1, -1 ); + mea->setName( "pass" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique,elemPass_array) ); + mea->setElementType( domProfile_CG::domTechnique::domPass::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 6005, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 6005 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domProfile_CG::domTechnique,_contents)); + meta->addContentsOrder(daeOffsetOf(domProfile_CG::domTechnique,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domProfile_CG::domTechnique,_CMData), 2); + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domProfile_CG::domTechnique , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_CG::domTechnique , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_CG::domTechnique)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_CG::domTechnique::domPass::create(DAE& dae) +{ + domProfile_CG::domTechnique::domPassRef ref = new domProfile_CG::domTechnique::domPass(dae); + return ref; +} + + +daeMetaElement * +domProfile_CG::domTechnique::domPass::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "pass" ); + meta->registerClass(domProfile_CG::domTechnique::domPass::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "color_target" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass,elemColor_target_array) ); + mea->setElementType( domFx_colortarget_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "depth_target" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass,elemDepth_target_array) ); + mea->setElementType( domFx_depthtarget_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "stencil_target" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass,elemStencil_target_array) ); + mea->setElementType( domFx_stenciltarget_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 4, 0, -1 ); + mea->setName( "color_clear" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass,elemColor_clear_array) ); + mea->setElementType( domFx_clearcolor_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 5, 0, -1 ); + mea->setName( "depth_clear" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass,elemDepth_clear_array) ); + mea->setElementType( domFx_cleardepth_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 6, 0, -1 ); + mea->setName( "stencil_clear" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass,elemStencil_clear_array) ); + mea->setElementType( domFx_clearstencil_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "draw" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass,elemDraw) ); + mea->setElementType( domProfile_CG::domTechnique::domPass::domDraw::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 8, 1, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "gl_pipeline_settings" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass,elemGl_pipeline_settings_array) ); + mea->setElementType( domGl_pipeline_settings::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "shader" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass,elemShader_array) ); + mea->setElementType( domProfile_CG::domTechnique::domPass::domShader::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3009, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3009 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domProfile_CG::domTechnique::domPass,_contents)); + meta->addContentsOrder(daeOffsetOf(domProfile_CG::domTechnique::domPass,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domProfile_CG::domTechnique::domPass,_CMData), 1); + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_CG::domTechnique::domPass , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_CG::domTechnique::domPass)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_CG::domTechnique::domPass::domDraw::create(DAE& dae) +{ + domProfile_CG::domTechnique::domPass::domDrawRef ref = new domProfile_CG::domTechnique::domPass::domDraw(dae); + return ref; +} + + +daeMetaElement * +domProfile_CG::domTechnique::domPass::domDraw::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "draw" ); + meta->registerClass(domProfile_CG::domTechnique::domPass::domDraw::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_draw_common")); + ma->setOffset( daeOffsetOf( domProfile_CG::domTechnique::domPass::domDraw , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_CG::domTechnique::domPass::domDraw)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_CG::domTechnique::domPass::domShader::create(DAE& dae) +{ + domProfile_CG::domTechnique::domPass::domShaderRef ref = new domProfile_CG::domTechnique::domPass::domShader(dae); + return ref; +} + + +daeMetaElement * +domProfile_CG::domTechnique::domPass::domShader::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "shader" ); + meta->registerClass(domProfile_CG::domTechnique::domPass::domShader::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass::domShader,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaSequence( meta, cm, 1, 0, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "compiler_target" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass::domShader,elemCompiler_target) ); + mea->setElementType( domProfile_CG::domTechnique::domPass::domShader::domCompiler_target::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "compiler_options" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass::domShader,elemCompiler_options) ); + mea->setElementType( domProfile_CG::domTechnique::domPass::domShader::domCompiler_options::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementAttribute( meta, cm, 3, 1, 1 ); + mea->setName( "name" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass::domShader,elemName) ); + mea->setElementType( domProfile_CG::domTechnique::domPass::domShader::domName::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 4, 0, -1 ); + mea->setName( "bind" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass::domShader,elemBind_array) ); + mea->setElementType( domProfile_CG::domTechnique::domPass::domShader::domBind::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 4 ); + meta->setCMRoot( cm ); + + // Add attribute: stage + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "stage" ); + ma->setType( dae.getAtomicTypes().get("Cg_pipeline_stage")); + ma->setOffset( daeOffsetOf( domProfile_CG::domTechnique::domPass::domShader , attrStage )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_CG::domTechnique::domPass::domShader)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_CG::domTechnique::domPass::domShader::domCompiler_target::create(DAE& dae) +{ + domProfile_CG::domTechnique::domPass::domShader::domCompiler_targetRef ref = new domProfile_CG::domTechnique::domPass::domShader::domCompiler_target(dae); + return ref; +} + + +daeMetaElement * +domProfile_CG::domTechnique::domPass::domShader::domCompiler_target::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "compiler_target" ); + meta->registerClass(domProfile_CG::domTechnique::domPass::domShader::domCompiler_target::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNMTOKEN")); + ma->setOffset( daeOffsetOf( domProfile_CG::domTechnique::domPass::domShader::domCompiler_target , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_CG::domTechnique::domPass::domShader::domCompiler_target)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_CG::domTechnique::domPass::domShader::domCompiler_options::create(DAE& dae) +{ + domProfile_CG::domTechnique::domPass::domShader::domCompiler_optionsRef ref = new domProfile_CG::domTechnique::domPass::domShader::domCompiler_options(dae); + return ref; +} + + +daeMetaElement * +domProfile_CG::domTechnique::domPass::domShader::domCompiler_options::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "compiler_options" ); + meta->registerClass(domProfile_CG::domTechnique::domPass::domShader::domCompiler_options::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domProfile_CG::domTechnique::domPass::domShader::domCompiler_options , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_CG::domTechnique::domPass::domShader::domCompiler_options)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_CG::domTechnique::domPass::domShader::domName::create(DAE& dae) +{ + domProfile_CG::domTechnique::domPass::domShader::domNameRef ref = new domProfile_CG::domTechnique::domPass::domShader::domName(dae); + return ref; +} + + +daeMetaElement * +domProfile_CG::domTechnique::domPass::domShader::domName::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "name" ); + meta->registerClass(domProfile_CG::domTechnique::domPass::domShader::domName::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_CG::domTechnique::domPass::domShader::domName , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: source + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "source" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_CG::domTechnique::domPass::domShader::domName , attrSource )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_CG::domTechnique::domPass::domShader::domName)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_CG::domTechnique::domPass::domShader::domBind::create(DAE& dae) +{ + domProfile_CG::domTechnique::domPass::domShader::domBindRef ref = new domProfile_CG::domTechnique::domPass::domShader::domBind(dae); + return ref; +} + + +daeMetaElement * +domProfile_CG::domTechnique::domPass::domShader::domBind::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bind" ); + meta->registerClass(domProfile_CG::domTechnique::domPass::domShader::domBind::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "cg_param_type" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass::domShader::domBind,elemCg_param_type) ); + mea->setElementType( domCg_param_type::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "param" ); + mea->setOffset( daeOffsetOf(domProfile_CG::domTechnique::domPass::domShader::domBind,elemParam) ); + mea->setElementType( domProfile_CG::domTechnique::domPass::domShader::domBind::domParam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domProfile_CG::domTechnique::domPass::domShader::domBind,_contents)); + meta->addContentsOrder(daeOffsetOf(domProfile_CG::domTechnique::domPass::domShader::domBind,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domProfile_CG::domTechnique::domPass::domShader::domBind,_CMData), 1); + // Add attribute: symbol + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "symbol" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_CG::domTechnique::domPass::domShader::domBind , attrSymbol )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_CG::domTechnique::domPass::domShader::domBind)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_CG::domTechnique::domPass::domShader::domBind::domParam::create(DAE& dae) +{ + domProfile_CG::domTechnique::domPass::domShader::domBind::domParamRef ref = new domProfile_CG::domTechnique::domPass::domShader::domBind::domParam(dae); + return ref; +} + + +daeMetaElement * +domProfile_CG::domTechnique::domPass::domShader::domBind::domParam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "param" ); + meta->registerClass(domProfile_CG::domTechnique::domPass::domShader::domBind::domParam::create); + + meta->setIsInnerClass( true ); + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_CG::domTechnique::domPass::domShader::domBind::domParam , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_CG::domTechnique::domPass::domShader::domBind::domParam)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domProfile_COMMON.cpp b/1.4.0/dom/src/1.4/dom/domProfile_COMMON.cpp new file mode 100644 index 0000000..1c32ca2 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domProfile_COMMON.cpp @@ -0,0 +1,561 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domProfile_COMMON.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domProfile_COMMON::create(DAE& dae) +{ + domProfile_COMMONRef ref = new domProfile_COMMON(dae); + return ref; +} + + +daeMetaElement * +domProfile_COMMON::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "profile_COMMON" ); + meta->registerClass(domProfile_COMMON::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "image" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON,elemImage_array) ); + mea->setElementType( domImage::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "newparam" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON,elemNewparam_array) ); + mea->setElementType( domCommon_newparam_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementAttribute( meta, cm, 3002, 1, 1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON,elemTechnique) ); + mea->setElementType( domProfile_COMMON::domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3003, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3003 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domProfile_COMMON,_contents)); + meta->addContentsOrder(daeOffsetOf(domProfile_COMMON,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domProfile_COMMON,_CMData), 1); + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domProfile_COMMON , attrId )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_COMMON)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_COMMON::domTechnique::create(DAE& dae) +{ + domProfile_COMMON::domTechniqueRef ref = new domProfile_COMMON::domTechnique(dae); + return ref; +} + + +daeMetaElement * +domProfile_COMMON::domTechnique::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "technique" ); + meta->registerClass(domProfile_COMMON::domTechnique::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "image" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique,elemImage_array) ); + mea->setElementType( domImage::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "newparam" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique,elemNewparam_array) ); + mea->setElementType( domCommon_newparam_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm = new daeMetaChoice( meta, cm, 1, 3002, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "constant" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique,elemConstant) ); + mea->setElementType( domProfile_COMMON::domTechnique::domConstant::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "lambert" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique,elemLambert) ); + mea->setElementType( domProfile_COMMON::domTechnique::domLambert::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "phong" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique,elemPhong) ); + mea->setElementType( domProfile_COMMON::domTechnique::domPhong::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "blinn" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique,elemBlinn) ); + mea->setElementType( domProfile_COMMON::domTechnique::domBlinn::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3003, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3003 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domProfile_COMMON::domTechnique,_contents)); + meta->addContentsOrder(daeOffsetOf(domProfile_COMMON::domTechnique,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domProfile_COMMON::domTechnique,_CMData), 2); + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domProfile_COMMON::domTechnique , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_COMMON::domTechnique , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_COMMON::domTechnique)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_COMMON::domTechnique::domConstant::create(DAE& dae) +{ + domProfile_COMMON::domTechnique::domConstantRef ref = new domProfile_COMMON::domTechnique::domConstant(dae); + return ref; +} + + +daeMetaElement * +domProfile_COMMON::domTechnique::domConstant::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "constant" ); + meta->registerClass(domProfile_COMMON::domTechnique::domConstant::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "emission" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domConstant,elemEmission) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "reflective" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domConstant,elemReflective) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "reflectivity" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domConstant,elemReflectivity) ); + mea->setElementType( domCommon_float_or_param_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "transparent" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domConstant,elemTransparent) ); + mea->setElementType( domCommon_transparent_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "transparency" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domConstant,elemTransparency) ); + mea->setElementType( domCommon_float_or_param_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "index_of_refraction" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domConstant,elemIndex_of_refraction) ); + mea->setElementType( domCommon_float_or_param_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 5 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domProfile_COMMON::domTechnique::domConstant)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_COMMON::domTechnique::domLambert::create(DAE& dae) +{ + domProfile_COMMON::domTechnique::domLambertRef ref = new domProfile_COMMON::domTechnique::domLambert(dae); + return ref; +} + + +daeMetaElement * +domProfile_COMMON::domTechnique::domLambert::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "lambert" ); + meta->registerClass(domProfile_COMMON::domTechnique::domLambert::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "emission" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domLambert,elemEmission) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "ambient" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domLambert,elemAmbient) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "diffuse" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domLambert,elemDiffuse) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "reflective" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domLambert,elemReflective) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "reflectivity" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domLambert,elemReflectivity) ); + mea->setElementType( domCommon_float_or_param_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "transparent" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domLambert,elemTransparent) ); + mea->setElementType( domCommon_transparent_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "transparency" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domLambert,elemTransparency) ); + mea->setElementType( domCommon_float_or_param_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "index_of_refraction" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domLambert,elemIndex_of_refraction) ); + mea->setElementType( domCommon_float_or_param_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 7 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domProfile_COMMON::domTechnique::domLambert)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_COMMON::domTechnique::domPhong::create(DAE& dae) +{ + domProfile_COMMON::domTechnique::domPhongRef ref = new domProfile_COMMON::domTechnique::domPhong(dae); + return ref; +} + + +daeMetaElement * +domProfile_COMMON::domTechnique::domPhong::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "phong" ); + meta->registerClass(domProfile_COMMON::domTechnique::domPhong::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "emission" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domPhong,elemEmission) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "ambient" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domPhong,elemAmbient) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "diffuse" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domPhong,elemDiffuse) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "specular" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domPhong,elemSpecular) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "shininess" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domPhong,elemShininess) ); + mea->setElementType( domCommon_float_or_param_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "reflective" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domPhong,elemReflective) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "reflectivity" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domPhong,elemReflectivity) ); + mea->setElementType( domCommon_float_or_param_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "transparent" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domPhong,elemTransparent) ); + mea->setElementType( domCommon_transparent_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 8, 0, 1 ); + mea->setName( "transparency" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domPhong,elemTransparency) ); + mea->setElementType( domCommon_float_or_param_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 9, 0, 1 ); + mea->setName( "index_of_refraction" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domPhong,elemIndex_of_refraction) ); + mea->setElementType( domCommon_float_or_param_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 9 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domProfile_COMMON::domTechnique::domPhong)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_COMMON::domTechnique::domBlinn::create(DAE& dae) +{ + domProfile_COMMON::domTechnique::domBlinnRef ref = new domProfile_COMMON::domTechnique::domBlinn(dae); + return ref; +} + + +daeMetaElement * +domProfile_COMMON::domTechnique::domBlinn::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "blinn" ); + meta->registerClass(domProfile_COMMON::domTechnique::domBlinn::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "emission" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domBlinn,elemEmission) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "ambient" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domBlinn,elemAmbient) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "diffuse" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domBlinn,elemDiffuse) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "specular" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domBlinn,elemSpecular) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "shininess" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domBlinn,elemShininess) ); + mea->setElementType( domCommon_float_or_param_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "reflective" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domBlinn,elemReflective) ); + mea->setElementType( domCommon_color_or_texture_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "reflectivity" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domBlinn,elemReflectivity) ); + mea->setElementType( domCommon_float_or_param_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "transparent" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domBlinn,elemTransparent) ); + mea->setElementType( domCommon_transparent_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 8, 0, 1 ); + mea->setName( "transparency" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domBlinn,elemTransparency) ); + mea->setElementType( domCommon_float_or_param_type::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 9, 0, 1 ); + mea->setName( "index_of_refraction" ); + mea->setOffset( daeOffsetOf(domProfile_COMMON::domTechnique::domBlinn,elemIndex_of_refraction) ); + mea->setElementType( domCommon_float_or_param_type::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 9 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domProfile_COMMON::domTechnique::domBlinn)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domProfile_GLES.cpp b/1.4.0/dom/src/1.4/dom/domProfile_GLES.cpp new file mode 100644 index 0000000..ae4c1af --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domProfile_GLES.cpp @@ -0,0 +1,650 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domProfile_GLES.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domProfile_GLES::create(DAE& dae) +{ + domProfile_GLESRef ref = new domProfile_GLES(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLES::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "profile_GLES" ); + meta->registerClass(domProfile_GLES::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domProfile_GLES,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "image" ); + mea->setOffset( daeOffsetOf(domProfile_GLES,elemImage_array) ); + mea->setElementType( domImage::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "newparam" ); + mea->setOffset( daeOffsetOf(domProfile_GLES,elemNewparam_array) ); + mea->setElementType( domGles_newparam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3002, 1, -1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domProfile_GLES,elemTechnique_array) ); + mea->setElementType( domProfile_GLES::domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3003, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domProfile_GLES,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3003 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domProfile_GLES,_contents)); + meta->addContentsOrder(daeOffsetOf(domProfile_GLES,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domProfile_GLES,_CMData), 1); + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domProfile_GLES , attrId )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: platform + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "platform" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_GLES , attrPlatform )); + ma->setContainer( meta ); + ma->setDefaultString( "PC"); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLES)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLES::domTechnique::create(DAE& dae) +{ + domProfile_GLES::domTechniqueRef ref = new domProfile_GLES::domTechnique(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLES::domTechnique::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "technique" ); + meta->registerClass(domProfile_GLES::domTechnique::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 2, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "image" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique,elemImage_array) ); + mea->setElementType( domImage::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "newparam" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique,elemNewparam_array) ); + mea->setElementType( domGles_newparam::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "setparam" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique,elemSetparam_array) ); + mea->setElementType( domProfile_GLES::domTechnique::domSetparam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3003, 1, -1 ); + mea->setName( "pass" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique,elemPass_array) ); + mea->setElementType( domProfile_GLES::domTechnique::domPass::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3004, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3004 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domProfile_GLES::domTechnique,_contents)); + meta->addContentsOrder(daeOffsetOf(domProfile_GLES::domTechnique,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domProfile_GLES::domTechnique,_CMData), 1); + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domProfile_GLES::domTechnique , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_GLES::domTechnique , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLES::domTechnique)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLES::domTechnique::domSetparam::create(DAE& dae) +{ + domProfile_GLES::domTechnique::domSetparamRef ref = new domProfile_GLES::domTechnique::domSetparam(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLES::domTechnique::domSetparam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "setparam" ); + meta->registerClass(domProfile_GLES::domTechnique::domSetparam::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique::domSetparam,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "gles_basic_type_common" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique::domSetparam,elemGles_basic_type_common) ); + mea->setElementType( domGles_basic_type_common::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 1, 1, 1 ) ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_GLES::domTechnique::domSetparam , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLES::domTechnique::domSetparam)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLES::domTechnique::domPass::create(DAE& dae) +{ + domProfile_GLES::domTechnique::domPassRef ref = new domProfile_GLES::domTechnique::domPass(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLES::domTechnique::domPass::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "pass" ); + meta->registerClass(domProfile_GLES::domTechnique::domPass::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique::domPass,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "color_target" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique::domPass,elemColor_target) ); + mea->setElementType( domProfile_GLES::domTechnique::domPass::domColor_target::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "depth_target" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique::domPass,elemDepth_target) ); + mea->setElementType( domProfile_GLES::domTechnique::domPass::domDepth_target::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "stencil_target" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique::domPass,elemStencil_target) ); + mea->setElementType( domProfile_GLES::domTechnique::domPass::domStencil_target::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 4, 0, 1 ); + mea->setName( "color_clear" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique::domPass,elemColor_clear) ); + mea->setElementType( domProfile_GLES::domTechnique::domPass::domColor_clear::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 5, 0, 1 ); + mea->setName( "depth_clear" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique::domPass,elemDepth_clear) ); + mea->setElementType( domProfile_GLES::domTechnique::domPass::domDepth_clear::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 6, 0, 1 ); + mea->setName( "stencil_clear" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique::domPass,elemStencil_clear) ); + mea->setElementType( domProfile_GLES::domTechnique::domPass::domStencil_clear::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "draw" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique::domPass,elemDraw) ); + mea->setElementType( domProfile_GLES::domTechnique::domPass::domDraw::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 8, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "gles_pipeline_settings" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique::domPass,elemGles_pipeline_settings_array) ); + mea->setElementType( domGles_pipeline_settings::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3009, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domProfile_GLES::domTechnique::domPass,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3009 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domProfile_GLES::domTechnique::domPass,_contents)); + meta->addContentsOrder(daeOffsetOf(domProfile_GLES::domTechnique::domPass,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domProfile_GLES::domTechnique::domPass,_CMData), 1); + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_GLES::domTechnique::domPass , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLES::domTechnique::domPass)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLES::domTechnique::domPass::domColor_target::create(DAE& dae) +{ + domProfile_GLES::domTechnique::domPass::domColor_targetRef ref = new domProfile_GLES::domTechnique::domPass::domColor_target(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLES::domTechnique::domPass::domColor_target::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "color_target" ); + meta->registerClass(domProfile_GLES::domTechnique::domPass::domColor_target::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Gles_rendertarget_common")); + ma->setOffset( daeOffsetOf( domProfile_GLES::domTechnique::domPass::domColor_target , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLES::domTechnique::domPass::domColor_target)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLES::domTechnique::domPass::domDepth_target::create(DAE& dae) +{ + domProfile_GLES::domTechnique::domPass::domDepth_targetRef ref = new domProfile_GLES::domTechnique::domPass::domDepth_target(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLES::domTechnique::domPass::domDepth_target::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "depth_target" ); + meta->registerClass(domProfile_GLES::domTechnique::domPass::domDepth_target::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Gles_rendertarget_common")); + ma->setOffset( daeOffsetOf( domProfile_GLES::domTechnique::domPass::domDepth_target , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLES::domTechnique::domPass::domDepth_target)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLES::domTechnique::domPass::domStencil_target::create(DAE& dae) +{ + domProfile_GLES::domTechnique::domPass::domStencil_targetRef ref = new domProfile_GLES::domTechnique::domPass::domStencil_target(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLES::domTechnique::domPass::domStencil_target::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "stencil_target" ); + meta->registerClass(domProfile_GLES::domTechnique::domPass::domStencil_target::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Gles_rendertarget_common")); + ma->setOffset( daeOffsetOf( domProfile_GLES::domTechnique::domPass::domStencil_target , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLES::domTechnique::domPass::domStencil_target)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLES::domTechnique::domPass::domColor_clear::create(DAE& dae) +{ + domProfile_GLES::domTechnique::domPass::domColor_clearRef ref = new domProfile_GLES::domTechnique::domPass::domColor_clear(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLES::domTechnique::domPass::domColor_clear::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "color_clear" ); + meta->registerClass(domProfile_GLES::domTechnique::domPass::domColor_clear::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_color_common")); + ma->setOffset( daeOffsetOf( domProfile_GLES::domTechnique::domPass::domColor_clear , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLES::domTechnique::domPass::domColor_clear)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLES::domTechnique::domPass::domDepth_clear::create(DAE& dae) +{ + domProfile_GLES::domTechnique::domPass::domDepth_clearRef ref = new domProfile_GLES::domTechnique::domPass::domDepth_clear(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLES::domTechnique::domPass::domDepth_clear::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "depth_clear" ); + meta->registerClass(domProfile_GLES::domTechnique::domPass::domDepth_clear::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domProfile_GLES::domTechnique::domPass::domDepth_clear , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLES::domTechnique::domPass::domDepth_clear)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLES::domTechnique::domPass::domStencil_clear::create(DAE& dae) +{ + domProfile_GLES::domTechnique::domPass::domStencil_clearRef ref = new domProfile_GLES::domTechnique::domPass::domStencil_clear(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLES::domTechnique::domPass::domStencil_clear::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "stencil_clear" ); + meta->registerClass(domProfile_GLES::domTechnique::domPass::domStencil_clear::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsByte")); + ma->setOffset( daeOffsetOf( domProfile_GLES::domTechnique::domPass::domStencil_clear , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLES::domTechnique::domPass::domStencil_clear)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLES::domTechnique::domPass::domDraw::create(DAE& dae) +{ + domProfile_GLES::domTechnique::domPass::domDrawRef ref = new domProfile_GLES::domTechnique::domPass::domDraw(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLES::domTechnique::domPass::domDraw::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "draw" ); + meta->registerClass(domProfile_GLES::domTechnique::domPass::domDraw::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_draw_common")); + ma->setOffset( daeOffsetOf( domProfile_GLES::domTechnique::domPass::domDraw , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLES::domTechnique::domPass::domDraw)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domProfile_GLSL.cpp b/1.4.0/dom/src/1.4/dom/domProfile_GLSL.cpp new file mode 100644 index 0000000..6a52c2a --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domProfile_GLSL.cpp @@ -0,0 +1,700 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domProfile_GLSL.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domProfile_GLSL::create(DAE& dae) +{ + domProfile_GLSLRef ref = new domProfile_GLSL(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLSL::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "profile_GLSL" ); + meta->registerClass(domProfile_GLSL::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "code" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL,elemCode_array) ); + mea->setElementType( domFx_code_profile::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "include" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL,elemInclude_array) ); + mea->setElementType( domFx_include_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm = new daeMetaChoice( meta, cm, 1, 3002, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "image" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL,elemImage_array) ); + mea->setElementType( domImage::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "newparam" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL,elemNewparam_array) ); + mea->setElementType( domGlsl_newparam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 6003, 1, -1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL,elemTechnique_array) ); + mea->setElementType( domProfile_GLSL::domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 6004, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 6004 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domProfile_GLSL,_contents)); + meta->addContentsOrder(daeOffsetOf(domProfile_GLSL,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domProfile_GLSL,_CMData), 2); + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domProfile_GLSL , attrId )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLSL)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLSL::domTechnique::create(DAE& dae) +{ + domProfile_GLSL::domTechniqueRef ref = new domProfile_GLSL::domTechnique(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLSL::domTechnique::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "technique" ); + meta->registerClass(domProfile_GLSL::domTechnique::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "code" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique,elemCode_array) ); + mea->setElementType( domFx_code_profile::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "include" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique,elemInclude_array) ); + mea->setElementType( domFx_include_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm = new daeMetaChoice( meta, cm, 1, 3002, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "image" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique,elemImage_array) ); + mea->setElementType( domImage::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "newparam" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique,elemNewparam_array) ); + mea->setElementType( domGlsl_newparam::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "setparam" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique,elemSetparam_array) ); + mea->setElementType( domGlsl_setparam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 6003, 1, -1 ); + mea->setName( "pass" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique,elemPass_array) ); + mea->setElementType( domProfile_GLSL::domTechnique::domPass::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 6004, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 6004 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domProfile_GLSL::domTechnique,_contents)); + meta->addContentsOrder(daeOffsetOf(domProfile_GLSL::domTechnique,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domProfile_GLSL::domTechnique,_CMData), 2); + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domProfile_GLSL::domTechnique , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_GLSL::domTechnique , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLSL::domTechnique)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLSL::domTechnique::domPass::create(DAE& dae) +{ + domProfile_GLSL::domTechnique::domPassRef ref = new domProfile_GLSL::domTechnique::domPass(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLSL::domTechnique::domPass::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "pass" ); + meta->registerClass(domProfile_GLSL::domTechnique::domPass::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "color_target" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass,elemColor_target_array) ); + mea->setElementType( domFx_colortarget_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "depth_target" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass,elemDepth_target_array) ); + mea->setElementType( domFx_depthtarget_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "stencil_target" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass,elemStencil_target_array) ); + mea->setElementType( domFx_stenciltarget_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 4, 0, -1 ); + mea->setName( "color_clear" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass,elemColor_clear_array) ); + mea->setElementType( domFx_clearcolor_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 5, 0, -1 ); + mea->setName( "depth_clear" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass,elemDepth_clear_array) ); + mea->setElementType( domFx_cleardepth_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 6, 0, -1 ); + mea->setName( "stencil_clear" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass,elemStencil_clear_array) ); + mea->setElementType( domFx_clearstencil_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 7, 0, 1 ); + mea->setName( "draw" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass,elemDraw) ); + mea->setElementType( domProfile_GLSL::domTechnique::domPass::domDraw::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 8, 1, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "gl_pipeline_settings" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass,elemGl_pipeline_settings_array) ); + mea->setElementType( domGl_pipeline_settings::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "shader" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass,elemShader_array) ); + mea->setElementType( domProfile_GLSL::domTechnique::domPass::domShader::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3009, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3009 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domProfile_GLSL::domTechnique::domPass,_contents)); + meta->addContentsOrder(daeOffsetOf(domProfile_GLSL::domTechnique::domPass,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domProfile_GLSL::domTechnique::domPass,_CMData), 1); + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_GLSL::domTechnique::domPass , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLSL::domTechnique::domPass)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLSL::domTechnique::domPass::domDraw::create(DAE& dae) +{ + domProfile_GLSL::domTechnique::domPass::domDrawRef ref = new domProfile_GLSL::domTechnique::domPass::domDraw(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLSL::domTechnique::domPass::domDraw::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "draw" ); + meta->registerClass(domProfile_GLSL::domTechnique::domPass::domDraw::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Fx_draw_common")); + ma->setOffset( daeOffsetOf( domProfile_GLSL::domTechnique::domPass::domDraw , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLSL::domTechnique::domPass::domDraw)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLSL::domTechnique::domPass::domShader::create(DAE& dae) +{ + domProfile_GLSL::domTechnique::domPass::domShaderRef ref = new domProfile_GLSL::domTechnique::domPass::domShader(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLSL::domTechnique::domPass::domShader::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "shader" ); + meta->registerClass(domProfile_GLSL::domTechnique::domPass::domShader::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "annotate" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass::domShader,elemAnnotate_array) ); + mea->setElementType( domFx_annotate_common::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaSequence( meta, cm, 1, 0, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "compiler_target" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass::domShader,elemCompiler_target) ); + mea->setElementType( domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_target::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "compiler_options" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass::domShader,elemCompiler_options) ); + mea->setElementType( domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_options::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementAttribute( meta, cm, 3, 1, 1 ); + mea->setName( "name" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass::domShader,elemName) ); + mea->setElementType( domProfile_GLSL::domTechnique::domPass::domShader::domName::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 4, 0, -1 ); + mea->setName( "bind" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass::domShader,elemBind_array) ); + mea->setElementType( domProfile_GLSL::domTechnique::domPass::domShader::domBind::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 4 ); + meta->setCMRoot( cm ); + + // Add attribute: stage + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "stage" ); + ma->setType( dae.getAtomicTypes().get("Glsl_pipeline_stage")); + ma->setOffset( daeOffsetOf( domProfile_GLSL::domTechnique::domPass::domShader , attrStage )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLSL::domTechnique::domPass::domShader)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_target::create(DAE& dae) +{ + domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_targetRef ref = new domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_target(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_target::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "compiler_target" ); + meta->registerClass(domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_target::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNMTOKEN")); + ma->setOffset( daeOffsetOf( domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_target , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_target)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_options::create(DAE& dae) +{ + domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_optionsRef ref = new domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_options(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_options::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "compiler_options" ); + meta->registerClass(domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_options::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_options , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLSL::domTechnique::domPass::domShader::domCompiler_options)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLSL::domTechnique::domPass::domShader::domName::create(DAE& dae) +{ + domProfile_GLSL::domTechnique::domPass::domShader::domNameRef ref = new domProfile_GLSL::domTechnique::domPass::domShader::domName(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLSL::domTechnique::domPass::domShader::domName::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "name" ); + meta->registerClass(domProfile_GLSL::domTechnique::domPass::domShader::domName::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_GLSL::domTechnique::domPass::domShader::domName , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: source + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "source" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_GLSL::domTechnique::domPass::domShader::domName , attrSource )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLSL::domTechnique::domPass::domShader::domName)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLSL::domTechnique::domPass::domShader::domBind::create(DAE& dae) +{ + domProfile_GLSL::domTechnique::domPass::domShader::domBindRef ref = new domProfile_GLSL::domTechnique::domPass::domShader::domBind(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLSL::domTechnique::domPass::domShader::domBind::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bind" ); + meta->registerClass(domProfile_GLSL::domTechnique::domPass::domShader::domBind::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "glsl_param_type" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass::domShader::domBind,elemGlsl_param_type) ); + mea->setElementType( domGlsl_param_type::registerElement(dae) ); + cm->appendChild( new daeMetaGroup( mea, meta, cm, 0, 1, 1 ) ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "param" ); + mea->setOffset( daeOffsetOf(domProfile_GLSL::domTechnique::domPass::domShader::domBind,elemParam) ); + mea->setElementType( domProfile_GLSL::domTechnique::domPass::domShader::domBind::domParam::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domProfile_GLSL::domTechnique::domPass::domShader::domBind,_contents)); + meta->addContentsOrder(daeOffsetOf(domProfile_GLSL::domTechnique::domPass::domShader::domBind,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domProfile_GLSL::domTechnique::domPass::domShader::domBind,_CMData), 1); + // Add attribute: symbol + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "symbol" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domProfile_GLSL::domTechnique::domPass::domShader::domBind , attrSymbol )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLSL::domTechnique::domPass::domShader::domBind)); + meta->validate(); + + return meta; +} + +daeElementRef +domProfile_GLSL::domTechnique::domPass::domShader::domBind::domParam::create(DAE& dae) +{ + domProfile_GLSL::domTechnique::domPass::domShader::domBind::domParamRef ref = new domProfile_GLSL::domTechnique::domPass::domShader::domBind::domParam(dae); + return ref; +} + + +daeMetaElement * +domProfile_GLSL::domTechnique::domPass::domShader::domBind::domParam::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "param" ); + meta->registerClass(domProfile_GLSL::domTechnique::domPass::domShader::domBind::domParam::create); + + meta->setIsInnerClass( true ); + + // Add attribute: ref + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "ref" ); + ma->setType( dae.getAtomicTypes().get("xsString")); + ma->setOffset( daeOffsetOf( domProfile_GLSL::domTechnique::domPass::domShader::domBind::domParam , attrRef )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domProfile_GLSL::domTechnique::domPass::domShader::domBind::domParam)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domRigid_body.cpp b/1.4.0/dom/src/1.4/dom/domRigid_body.cpp new file mode 100644 index 0000000..ef9fada --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domRigid_body.cpp @@ -0,0 +1,473 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domRigid_body.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domRigid_body::create(DAE& dae) +{ + domRigid_bodyRef ref = new domRigid_body(dae); + return ref; +} + + +daeMetaElement * +domRigid_body::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "rigid_body" ); + meta->registerClass(domRigid_body::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "technique_common" ); + mea->setOffset( daeOffsetOf(domRigid_body,elemTechnique_common) ); + mea->setElementType( domRigid_body::domTechnique_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domRigid_body,elemTechnique_array) ); + mea->setElementType( domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domRigid_body,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domRigid_body , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domRigid_body , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domRigid_body)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_body::domTechnique_common::create(DAE& dae) +{ + domRigid_body::domTechnique_commonRef ref = new domRigid_body::domTechnique_common(dae); + return ref; +} + + +daeMetaElement * +domRigid_body::domTechnique_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "technique_common" ); + meta->registerClass(domRigid_body::domTechnique_common::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "dynamic" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common,elemDynamic) ); + mea->setElementType( domRigid_body::domTechnique_common::domDynamic::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "mass" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common,elemMass) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "mass_frame" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common,elemMass_frame) ); + mea->setElementType( domRigid_body::domTechnique_common::domMass_frame::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "inertia" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common,elemInertia) ); + mea->setElementType( domTargetableFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 4, 0, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "instance_physics_material" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common,elemInstance_physics_material) ); + mea->setElementType( domInstance_physics_material::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "physics_material" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common,elemPhysics_material) ); + mea->setElementType( domPhysics_material::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 5, 1, -1 ); + mea->setName( "shape" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common,elemShape_array) ); + mea->setElementType( domRigid_body::domTechnique_common::domShape::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 5 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domRigid_body::domTechnique_common,_contents)); + meta->addContentsOrder(daeOffsetOf(domRigid_body::domTechnique_common,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domRigid_body::domTechnique_common,_CMData), 1); + meta->setElementSize(sizeof(domRigid_body::domTechnique_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_body::domTechnique_common::domDynamic::create(DAE& dae) +{ + domRigid_body::domTechnique_common::domDynamicRef ref = new domRigid_body::domTechnique_common::domDynamic(dae); + return ref; +} + + +daeMetaElement * +domRigid_body::domTechnique_common::domDynamic::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "dynamic" ); + meta->registerClass(domRigid_body::domTechnique_common::domDynamic::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domRigid_body::domTechnique_common::domDynamic , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domRigid_body::domTechnique_common::domDynamic , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domRigid_body::domTechnique_common::domDynamic)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_body::domTechnique_common::domMass_frame::create(DAE& dae) +{ + domRigid_body::domTechnique_common::domMass_frameRef ref = new domRigid_body::domTechnique_common::domMass_frame(dae); + return ref; +} + + +daeMetaElement * +domRigid_body::domTechnique_common::domMass_frame::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "mass_frame" ); + meta->registerClass(domRigid_body::domTechnique_common::domMass_frame::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 1, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "translate" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domMass_frame,elemTranslate_array) ); + mea->setElementType( domTranslate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "rotate" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domMass_frame,elemRotate_array) ); + mea->setElementType( domRotate::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3000 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domRigid_body::domTechnique_common::domMass_frame,_contents)); + meta->addContentsOrder(daeOffsetOf(domRigid_body::domTechnique_common::domMass_frame,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domRigid_body::domTechnique_common::domMass_frame,_CMData), 1); + meta->setElementSize(sizeof(domRigid_body::domTechnique_common::domMass_frame)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_body::domTechnique_common::domShape::create(DAE& dae) +{ + domRigid_body::domTechnique_common::domShapeRef ref = new domRigid_body::domTechnique_common::domShape(dae); + return ref; +} + + +daeMetaElement * +domRigid_body::domTechnique_common::domShape::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "shape" ); + meta->registerClass(domRigid_body::domTechnique_common::domShape::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "hollow" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemHollow) ); + mea->setElementType( domRigid_body::domTechnique_common::domShape::domHollow::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "mass" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemMass) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "density" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemDensity) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 3, 0, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "instance_physics_material" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemInstance_physics_material) ); + mea->setElementType( domInstance_physics_material::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "physics_material" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemPhysics_material) ); + mea->setElementType( domPhysics_material::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm = new daeMetaChoice( meta, cm, 1, 4, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "instance_geometry" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemInstance_geometry) ); + mea->setElementType( domInstance_geometry::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "plane" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemPlane) ); + mea->setElementType( domPlane::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "box" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemBox) ); + mea->setElementType( domBox::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "sphere" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemSphere) ); + mea->setElementType( domSphere::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "cylinder" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemCylinder) ); + mea->setElementType( domCylinder::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "tapered_cylinder" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemTapered_cylinder) ); + mea->setElementType( domTapered_cylinder::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "capsule" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemCapsule) ); + mea->setElementType( domCapsule::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "tapered_capsule" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemTapered_capsule) ); + mea->setElementType( domTapered_capsule::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm = new daeMetaChoice( meta, cm, 2, 5, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "translate" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemTranslate_array) ); + mea->setElementType( domTranslate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "rotate" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemRotate_array) ); + mea->setElementType( domRotate::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3006, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domRigid_body::domTechnique_common::domShape,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3006 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domRigid_body::domTechnique_common::domShape,_contents)); + meta->addContentsOrder(daeOffsetOf(domRigid_body::domTechnique_common::domShape,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domRigid_body::domTechnique_common::domShape,_CMData), 3); + meta->setElementSize(sizeof(domRigid_body::domTechnique_common::domShape)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_body::domTechnique_common::domShape::domHollow::create(DAE& dae) +{ + domRigid_body::domTechnique_common::domShape::domHollowRef ref = new domRigid_body::domTechnique_common::domShape::domHollow(dae); + return ref; +} + + +daeMetaElement * +domRigid_body::domTechnique_common::domShape::domHollow::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "hollow" ); + meta->registerClass(domRigid_body::domTechnique_common::domShape::domHollow::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domRigid_body::domTechnique_common::domShape::domHollow , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domRigid_body::domTechnique_common::domShape::domHollow , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domRigid_body::domTechnique_common::domShape::domHollow)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domRigid_constraint.cpp b/1.4.0/dom/src/1.4/dom/domRigid_constraint.cpp new file mode 100644 index 0000000..f76eb32 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domRigid_constraint.cpp @@ -0,0 +1,671 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domRigid_constraint.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domRigid_constraint::create(DAE& dae) +{ + domRigid_constraintRef ref = new domRigid_constraint(dae); + return ref; +} + + +daeMetaElement * +domRigid_constraint::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "rigid_constraint" ); + meta->registerClass(domRigid_constraint::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "ref_attachment" ); + mea->setOffset( daeOffsetOf(domRigid_constraint,elemRef_attachment) ); + mea->setElementType( domRigid_constraint::domRef_attachment::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "attachment" ); + mea->setOffset( daeOffsetOf(domRigid_constraint,elemAttachment) ); + mea->setElementType( domRigid_constraint::domAttachment::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 1, 1 ); + mea->setName( "technique_common" ); + mea->setOffset( daeOffsetOf(domRigid_constraint,elemTechnique_common) ); + mea->setElementType( domRigid_constraint::domTechnique_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domRigid_constraint,elemTechnique_array) ); + mea->setElementType( domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 4, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domRigid_constraint,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 4 ); + meta->setCMRoot( cm ); + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domRigid_constraint , attrSid )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domRigid_constraint , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domRigid_constraint)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_constraint::domRef_attachment::create(DAE& dae) +{ + domRigid_constraint::domRef_attachmentRef ref = new domRigid_constraint::domRef_attachment(dae); + return ref; +} + + +daeMetaElement * +domRigid_constraint::domRef_attachment::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "ref_attachment" ); + meta->registerClass(domRigid_constraint::domRef_attachment::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "translate" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domRef_attachment,elemTranslate_array) ); + mea->setElementType( domTranslate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "rotate" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domRef_attachment,elemRotate_array) ); + mea->setElementType( domRotate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domRef_attachment,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3000 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domRigid_constraint::domRef_attachment,_contents)); + meta->addContentsOrder(daeOffsetOf(domRigid_constraint::domRef_attachment,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domRigid_constraint::domRef_attachment,_CMData), 1); + // Add attribute: rigid_body + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "rigid_body" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domRigid_constraint::domRef_attachment , attrRigid_body )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domRigid_constraint::domRef_attachment)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_constraint::domAttachment::create(DAE& dae) +{ + domRigid_constraint::domAttachmentRef ref = new domRigid_constraint::domAttachment(dae); + return ref; +} + + +daeMetaElement * +domRigid_constraint::domAttachment::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "attachment" ); + meta->registerClass(domRigid_constraint::domAttachment::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaChoice( meta, cm, 0, 0, 0, -1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "translate" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domAttachment,elemTranslate_array) ); + mea->setElementType( domTranslate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "rotate" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domAttachment,elemRotate_array) ); + mea->setElementType( domRotate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domAttachment,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3000 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domRigid_constraint::domAttachment,_contents)); + meta->addContentsOrder(daeOffsetOf(domRigid_constraint::domAttachment,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domRigid_constraint::domAttachment,_CMData), 1); + // Add attribute: rigid_body + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "rigid_body" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domRigid_constraint::domAttachment , attrRigid_body )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domRigid_constraint::domAttachment)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_constraint::domTechnique_common::create(DAE& dae) +{ + domRigid_constraint::domTechnique_commonRef ref = new domRigid_constraint::domTechnique_common(dae); + return ref; +} + + +daeMetaElement * +domRigid_constraint::domTechnique_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "technique_common" ); + meta->registerClass(domRigid_constraint::domTechnique_common::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "enabled" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common,elemEnabled) ); + mea->setElementType( domRigid_constraint::domTechnique_common::domEnabled::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "interpenetrate" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common,elemInterpenetrate) ); + mea->setElementType( domRigid_constraint::domTechnique_common::domInterpenetrate::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "limits" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common,elemLimits) ); + mea->setElementType( domRigid_constraint::domTechnique_common::domLimits::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 0, 1 ); + mea->setName( "spring" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common,elemSpring) ); + mea->setElementType( domRigid_constraint::domTechnique_common::domSpring::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domRigid_constraint::domTechnique_common)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_constraint::domTechnique_common::domEnabled::create(DAE& dae) +{ + domRigid_constraint::domTechnique_common::domEnabledRef ref = new domRigid_constraint::domTechnique_common::domEnabled(dae); + return ref; +} + + +daeMetaElement * +domRigid_constraint::domTechnique_common::domEnabled::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "enabled" ); + meta->registerClass(domRigid_constraint::domTechnique_common::domEnabled::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domRigid_constraint::domTechnique_common::domEnabled , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domRigid_constraint::domTechnique_common::domEnabled , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domRigid_constraint::domTechnique_common::domEnabled)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_constraint::domTechnique_common::domInterpenetrate::create(DAE& dae) +{ + domRigid_constraint::domTechnique_common::domInterpenetrateRef ref = new domRigid_constraint::domTechnique_common::domInterpenetrate(dae); + return ref; +} + + +daeMetaElement * +domRigid_constraint::domTechnique_common::domInterpenetrate::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "interpenetrate" ); + meta->registerClass(domRigid_constraint::domTechnique_common::domInterpenetrate::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domRigid_constraint::domTechnique_common::domInterpenetrate , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domRigid_constraint::domTechnique_common::domInterpenetrate , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domRigid_constraint::domTechnique_common::domInterpenetrate)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_constraint::domTechnique_common::domLimits::create(DAE& dae) +{ + domRigid_constraint::domTechnique_common::domLimitsRef ref = new domRigid_constraint::domTechnique_common::domLimits(dae); + return ref; +} + + +daeMetaElement * +domRigid_constraint::domTechnique_common::domLimits::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "limits" ); + meta->registerClass(domRigid_constraint::domTechnique_common::domLimits::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "swing_cone_and_twist" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common::domLimits,elemSwing_cone_and_twist) ); + mea->setElementType( domRigid_constraint::domTechnique_common::domLimits::domSwing_cone_and_twist::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "linear" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common::domLimits,elemLinear) ); + mea->setElementType( domRigid_constraint::domTechnique_common::domLimits::domLinear::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domRigid_constraint::domTechnique_common::domLimits)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_constraint::domTechnique_common::domLimits::domSwing_cone_and_twist::create(DAE& dae) +{ + domRigid_constraint::domTechnique_common::domLimits::domSwing_cone_and_twistRef ref = new domRigid_constraint::domTechnique_common::domLimits::domSwing_cone_and_twist(dae); + return ref; +} + + +daeMetaElement * +domRigid_constraint::domTechnique_common::domLimits::domSwing_cone_and_twist::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "swing_cone_and_twist" ); + meta->registerClass(domRigid_constraint::domTechnique_common::domLimits::domSwing_cone_and_twist::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "min" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common::domLimits::domSwing_cone_and_twist,elemMin) ); + mea->setElementType( domTargetableFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "max" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common::domLimits::domSwing_cone_and_twist,elemMax) ); + mea->setElementType( domTargetableFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domRigid_constraint::domTechnique_common::domLimits::domSwing_cone_and_twist)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_constraint::domTechnique_common::domLimits::domLinear::create(DAE& dae) +{ + domRigid_constraint::domTechnique_common::domLimits::domLinearRef ref = new domRigid_constraint::domTechnique_common::domLimits::domLinear(dae); + return ref; +} + + +daeMetaElement * +domRigid_constraint::domTechnique_common::domLimits::domLinear::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "linear" ); + meta->registerClass(domRigid_constraint::domTechnique_common::domLimits::domLinear::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "min" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common::domLimits::domLinear,elemMin) ); + mea->setElementType( domTargetableFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "max" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common::domLimits::domLinear,elemMax) ); + mea->setElementType( domTargetableFloat3::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domRigid_constraint::domTechnique_common::domLimits::domLinear)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_constraint::domTechnique_common::domSpring::create(DAE& dae) +{ + domRigid_constraint::domTechnique_common::domSpringRef ref = new domRigid_constraint::domTechnique_common::domSpring(dae); + return ref; +} + + +daeMetaElement * +domRigid_constraint::domTechnique_common::domSpring::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "spring" ); + meta->registerClass(domRigid_constraint::domTechnique_common::domSpring::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "angular" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common::domSpring,elemAngular) ); + mea->setElementType( domRigid_constraint::domTechnique_common::domSpring::domAngular::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "linear" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common::domSpring,elemLinear) ); + mea->setElementType( domRigid_constraint::domTechnique_common::domSpring::domLinear::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domRigid_constraint::domTechnique_common::domSpring)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_constraint::domTechnique_common::domSpring::domAngular::create(DAE& dae) +{ + domRigid_constraint::domTechnique_common::domSpring::domAngularRef ref = new domRigid_constraint::domTechnique_common::domSpring::domAngular(dae); + return ref; +} + + +daeMetaElement * +domRigid_constraint::domTechnique_common::domSpring::domAngular::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "angular" ); + meta->registerClass(domRigid_constraint::domTechnique_common::domSpring::domAngular::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "stiffness" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common::domSpring::domAngular,elemStiffness) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "damping" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common::domSpring::domAngular,elemDamping) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "target_value" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common::domSpring::domAngular,elemTarget_value) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domRigid_constraint::domTechnique_common::domSpring::domAngular)); + meta->validate(); + + return meta; +} + +daeElementRef +domRigid_constraint::domTechnique_common::domSpring::domLinear::create(DAE& dae) +{ + domRigid_constraint::domTechnique_common::domSpring::domLinearRef ref = new domRigid_constraint::domTechnique_common::domSpring::domLinear(dae); + return ref; +} + + +daeMetaElement * +domRigid_constraint::domTechnique_common::domSpring::domLinear::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "linear" ); + meta->registerClass(domRigid_constraint::domTechnique_common::domSpring::domLinear::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "stiffness" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common::domSpring::domLinear,elemStiffness) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "damping" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common::domSpring::domLinear,elemDamping) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "target_value" ); + mea->setOffset( daeOffsetOf(domRigid_constraint::domTechnique_common::domSpring::domLinear,elemTarget_value) ); + mea->setElementType( domTargetableFloat::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domRigid_constraint::domTechnique_common::domSpring::domLinear)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domRotate.cpp b/1.4.0/dom/src/1.4/dom/domRotate.cpp new file mode 100644 index 0000000..6e2ff7c --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domRotate.cpp @@ -0,0 +1,67 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domRotate.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domRotate::create(DAE& dae) +{ + domRotateRef ref = new domRotate(dae); + return ref; +} + + +daeMetaElement * +domRotate::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "rotate" ); + meta->registerClass(domRotate::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4")); + ma->setOffset( daeOffsetOf( domRotate , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domRotate , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domRotate)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domSampler.cpp b/1.4.0/dom/src/1.4/dom/domSampler.cpp new file mode 100644 index 0000000..8cb0cbd --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domSampler.cpp @@ -0,0 +1,70 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domSampler.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domSampler::create(DAE& dae) +{ + domSamplerRef ref = new domSampler(dae); + return ref; +} + + +daeMetaElement * +domSampler::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "sampler" ); + meta->registerClass(domSampler::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, -1 ); + mea->setName( "input" ); + mea->setOffset( daeOffsetOf(domSampler,elemInput_array) ); + mea->setElementType( domInputLocal::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domSampler , attrId )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domSampler)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domScale.cpp b/1.4.0/dom/src/1.4/dom/domScale.cpp new file mode 100644 index 0000000..97b5ac2 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domScale.cpp @@ -0,0 +1,67 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domScale.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domScale::create(DAE& dae) +{ + domScaleRef ref = new domScale(dae); + return ref; +} + + +daeMetaElement * +domScale::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "scale" ); + meta->registerClass(domScale::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domScale , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domScale , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domScale)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domSkew.cpp b/1.4.0/dom/src/1.4/dom/domSkew.cpp new file mode 100644 index 0000000..6e81741 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domSkew.cpp @@ -0,0 +1,67 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domSkew.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domSkew::create(DAE& dae) +{ + domSkewRef ref = new domSkew(dae); + return ref; +} + + +daeMetaElement * +domSkew::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "skew" ); + meta->registerClass(domSkew::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float7")); + ma->setOffset( daeOffsetOf( domSkew , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domSkew , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domSkew)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domSkin.cpp b/1.4.0/dom/src/1.4/dom/domSkin.cpp new file mode 100644 index 0000000..df5e2ed --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domSkin.cpp @@ -0,0 +1,317 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domSkin.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domSkin::create(DAE& dae) +{ + domSkinRef ref = new domSkin(dae); + return ref; +} + + +daeMetaElement * +domSkin::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "skin" ); + meta->registerClass(domSkin::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "bind_shape_matrix" ); + mea->setOffset( daeOffsetOf(domSkin,elemBind_shape_matrix) ); + mea->setElementType( domSkin::domBind_shape_matrix::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 3, -1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domSkin,elemSource_array) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 1, 1 ); + mea->setName( "joints" ); + mea->setOffset( daeOffsetOf(domSkin,elemJoints) ); + mea->setElementType( domSkin::domJoints::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 3, 1, 1 ); + mea->setName( "vertex_weights" ); + mea->setOffset( daeOffsetOf(domSkin,elemVertex_weights) ); + mea->setElementType( domSkin::domVertex_weights::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 4, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domSkin,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 4 ); + meta->setCMRoot( cm ); + + // Add attribute: source + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "source" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domSkin , attrSource )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domSkin)); + meta->validate(); + + return meta; +} + +daeElementRef +domSkin::domBind_shape_matrix::create(DAE& dae) +{ + domSkin::domBind_shape_matrixRef ref = new domSkin::domBind_shape_matrix(dae); + return ref; +} + + +daeMetaElement * +domSkin::domBind_shape_matrix::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "bind_shape_matrix" ); + meta->registerClass(domSkin::domBind_shape_matrix::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float4x4")); + ma->setOffset( daeOffsetOf( domSkin::domBind_shape_matrix , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domSkin::domBind_shape_matrix)); + meta->validate(); + + return meta; +} + +daeElementRef +domSkin::domJoints::create(DAE& dae) +{ + domSkin::domJointsRef ref = new domSkin::domJoints(dae); + return ref; +} + + +daeMetaElement * +domSkin::domJoints::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "joints" ); + meta->registerClass(domSkin::domJoints::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 2, -1 ); + mea->setName( "input" ); + mea->setOffset( daeOffsetOf(domSkin::domJoints,elemInput_array) ); + mea->setElementType( domInputLocal::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domSkin::domJoints,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domSkin::domJoints)); + meta->validate(); + + return meta; +} + +daeElementRef +domSkin::domVertex_weights::create(DAE& dae) +{ + domSkin::domVertex_weightsRef ref = new domSkin::domVertex_weights(dae); + return ref; +} + + +daeMetaElement * +domSkin::domVertex_weights::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "vertex_weights" ); + meta->registerClass(domSkin::domVertex_weights::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 2, -1 ); + mea->setName( "input" ); + mea->setOffset( daeOffsetOf(domSkin::domVertex_weights,elemInput_array) ); + mea->setElementType( domInputLocalOffset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "vcount" ); + mea->setOffset( daeOffsetOf(domSkin::domVertex_weights,elemVcount) ); + mea->setElementType( domSkin::domVertex_weights::domVcount::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "v" ); + mea->setOffset( daeOffsetOf(domSkin::domVertex_weights,elemV) ); + mea->setElementType( domSkin::domVertex_weights::domV::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domSkin::domVertex_weights,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + // Add attribute: count + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "count" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domSkin::domVertex_weights , attrCount )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domSkin::domVertex_weights)); + meta->validate(); + + return meta; +} + +daeElementRef +domSkin::domVertex_weights::domVcount::create(DAE& dae) +{ + domSkin::domVertex_weights::domVcountRef ref = new domSkin::domVertex_weights::domVcount(dae); + return ref; +} + + +daeMetaElement * +domSkin::domVertex_weights::domVcount::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "vcount" ); + meta->registerClass(domSkin::domVertex_weights::domVcount::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("ListOfUInts")); + ma->setOffset( daeOffsetOf( domSkin::domVertex_weights::domVcount , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domSkin::domVertex_weights::domVcount)); + meta->validate(); + + return meta; +} + +daeElementRef +domSkin::domVertex_weights::domV::create(DAE& dae) +{ + domSkin::domVertex_weights::domVRef ref = new domSkin::domVertex_weights::domV(dae); + return ref; +} + + +daeMetaElement * +domSkin::domVertex_weights::domV::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "v" ); + meta->registerClass(domSkin::domVertex_weights::domV::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("ListOfInts")); + ma->setOffset( daeOffsetOf( domSkin::domVertex_weights::domV , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domSkin::domVertex_weights::domV)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domSource.cpp b/1.4.0/dom/src/1.4/dom/domSource.cpp new file mode 100644 index 0000000..ddaac72 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domSource.cpp @@ -0,0 +1,173 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domSource.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domSource::create(DAE& dae) +{ + domSourceRef ref = new domSource(dae); + return ref; +} + + +daeMetaElement * +domSource::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "source" ); + meta->registerClass(domSource::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domSource,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + cm = new daeMetaChoice( meta, cm, 0, 1, 0, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "IDREF_array" ); + mea->setOffset( daeOffsetOf(domSource,elemIDREF_array) ); + mea->setElementType( domIDREF_array::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "Name_array" ); + mea->setOffset( daeOffsetOf(domSource,elemName_array) ); + mea->setElementType( domName_array::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "bool_array" ); + mea->setOffset( daeOffsetOf(domSource,elemBool_array) ); + mea->setElementType( domBool_array::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "float_array" ); + mea->setOffset( daeOffsetOf(domSource,elemFloat_array) ); + mea->setElementType( domFloat_array::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "int_array" ); + mea->setOffset( daeOffsetOf(domSource,elemInt_array) ); + mea->setElementType( domInt_array::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + mea = new daeMetaElementAttribute( meta, cm, 2, 0, 1 ); + mea->setName( "technique_common" ); + mea->setOffset( daeOffsetOf(domSource,elemTechnique_common) ); + mea->setElementType( domSource::domTechnique_common::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "technique" ); + mea->setOffset( daeOffsetOf(domSource,elemTechnique_array) ); + mea->setElementType( domTechnique::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domSource,_contents)); + meta->addContentsOrder(daeOffsetOf(domSource,_contentsOrder)); + + meta->addCMDataArray(daeOffsetOf(domSource,_CMData), 1); + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domSource , attrId )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domSource , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domSource)); + meta->validate(); + + return meta; +} + +daeElementRef +domSource::domTechnique_common::create(DAE& dae) +{ + domSource::domTechnique_commonRef ref = new domSource::domTechnique_common(dae); + return ref; +} + + +daeMetaElement * +domSource::domTechnique_common::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "technique_common" ); + meta->registerClass(domSource::domTechnique_common::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "accessor" ); + mea->setOffset( daeOffsetOf(domSource::domTechnique_common,elemAccessor) ); + mea->setElementType( domAccessor::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domSource::domTechnique_common)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domSphere.cpp b/1.4.0/dom/src/1.4/dom/domSphere.cpp new file mode 100644 index 0000000..53df9f0 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domSphere.cpp @@ -0,0 +1,101 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domSphere.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domSphere::create(DAE& dae) +{ + domSphereRef ref = new domSphere(dae); + return ref; +} + + +daeMetaElement * +domSphere::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "sphere" ); + meta->registerClass(domSphere::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "radius" ); + mea->setOffset( daeOffsetOf(domSphere,elemRadius) ); + mea->setElementType( domSphere::domRadius::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domSphere,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domSphere)); + meta->validate(); + + return meta; +} + +daeElementRef +domSphere::domRadius::create(DAE& dae) +{ + domSphere::domRadiusRef ref = new domSphere::domRadius(dae); + return ref; +} + + +daeMetaElement * +domSphere::domRadius::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "radius" ); + meta->registerClass(domSphere::domRadius::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domSphere::domRadius , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domSphere::domRadius)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domSpline.cpp b/1.4.0/dom/src/1.4/dom/domSpline.cpp new file mode 100644 index 0000000..b56f899 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domSpline.cpp @@ -0,0 +1,128 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domSpline.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domSpline::create(DAE& dae) +{ + domSplineRef ref = new domSpline(dae); + return ref; +} + + +daeMetaElement * +domSpline::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "spline" ); + meta->registerClass(domSpline::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, -1 ); + mea->setName( "source" ); + mea->setOffset( daeOffsetOf(domSpline,elemSource_array) ); + mea->setElementType( domSource::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "control_vertices" ); + mea->setOffset( daeOffsetOf(domSpline,elemControl_vertices) ); + mea->setElementType( domSpline::domControl_vertices::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domSpline,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: closed + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "closed" ); + ma->setType( dae.getAtomicTypes().get("Bool")); + ma->setOffset( daeOffsetOf( domSpline , attrClosed )); + ma->setContainer( meta ); + ma->setDefaultString( "false"); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domSpline)); + meta->validate(); + + return meta; +} + +daeElementRef +domSpline::domControl_vertices::create(DAE& dae) +{ + domSpline::domControl_verticesRef ref = new domSpline::domControl_vertices(dae); + return ref; +} + + +daeMetaElement * +domSpline::domControl_vertices::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "control_vertices" ); + meta->registerClass(domSpline::domControl_vertices::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, -1 ); + mea->setName( "input" ); + mea->setOffset( daeOffsetOf(domSpline::domControl_vertices,elemInput_array) ); + mea->setElementType( domInputLocal::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domSpline::domControl_vertices,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domSpline::domControl_vertices)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domTapered_capsule.cpp b/1.4.0/dom/src/1.4/dom/domTapered_capsule.cpp new file mode 100644 index 0000000..a641391 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domTapered_capsule.cpp @@ -0,0 +1,185 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domTapered_capsule.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domTapered_capsule::create(DAE& dae) +{ + domTapered_capsuleRef ref = new domTapered_capsule(dae); + return ref; +} + + +daeMetaElement * +domTapered_capsule::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "tapered_capsule" ); + meta->registerClass(domTapered_capsule::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "height" ); + mea->setOffset( daeOffsetOf(domTapered_capsule,elemHeight) ); + mea->setElementType( domTapered_capsule::domHeight::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "radius1" ); + mea->setOffset( daeOffsetOf(domTapered_capsule,elemRadius1) ); + mea->setElementType( domTapered_capsule::domRadius1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 1, 1 ); + mea->setName( "radius2" ); + mea->setOffset( daeOffsetOf(domTapered_capsule,elemRadius2) ); + mea->setElementType( domTapered_capsule::domRadius2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domTapered_capsule,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domTapered_capsule)); + meta->validate(); + + return meta; +} + +daeElementRef +domTapered_capsule::domHeight::create(DAE& dae) +{ + domTapered_capsule::domHeightRef ref = new domTapered_capsule::domHeight(dae); + return ref; +} + + +daeMetaElement * +domTapered_capsule::domHeight::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "height" ); + meta->registerClass(domTapered_capsule::domHeight::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domTapered_capsule::domHeight , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domTapered_capsule::domHeight)); + meta->validate(); + + return meta; +} + +daeElementRef +domTapered_capsule::domRadius1::create(DAE& dae) +{ + domTapered_capsule::domRadius1Ref ref = new domTapered_capsule::domRadius1(dae); + return ref; +} + + +daeMetaElement * +domTapered_capsule::domRadius1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "radius1" ); + meta->registerClass(domTapered_capsule::domRadius1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domTapered_capsule::domRadius1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domTapered_capsule::domRadius1)); + meta->validate(); + + return meta; +} + +daeElementRef +domTapered_capsule::domRadius2::create(DAE& dae) +{ + domTapered_capsule::domRadius2Ref ref = new domTapered_capsule::domRadius2(dae); + return ref; +} + + +daeMetaElement * +domTapered_capsule::domRadius2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "radius2" ); + meta->registerClass(domTapered_capsule::domRadius2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domTapered_capsule::domRadius2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domTapered_capsule::domRadius2)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domTapered_cylinder.cpp b/1.4.0/dom/src/1.4/dom/domTapered_cylinder.cpp new file mode 100644 index 0000000..5e8757e --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domTapered_cylinder.cpp @@ -0,0 +1,185 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domTapered_cylinder.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domTapered_cylinder::create(DAE& dae) +{ + domTapered_cylinderRef ref = new domTapered_cylinder(dae); + return ref; +} + + +daeMetaElement * +domTapered_cylinder::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "tapered_cylinder" ); + meta->registerClass(domTapered_cylinder::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 1, 1 ); + mea->setName( "height" ); + mea->setOffset( daeOffsetOf(domTapered_cylinder,elemHeight) ); + mea->setElementType( domTapered_cylinder::domHeight::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 1, 1 ); + mea->setName( "radius1" ); + mea->setOffset( daeOffsetOf(domTapered_cylinder,elemRadius1) ); + mea->setElementType( domTapered_cylinder::domRadius1::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 2, 1, 1 ); + mea->setName( "radius2" ); + mea->setOffset( daeOffsetOf(domTapered_cylinder,elemRadius2) ); + mea->setElementType( domTapered_cylinder::domRadius2::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domTapered_cylinder,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + meta->setElementSize(sizeof(domTapered_cylinder)); + meta->validate(); + + return meta; +} + +daeElementRef +domTapered_cylinder::domHeight::create(DAE& dae) +{ + domTapered_cylinder::domHeightRef ref = new domTapered_cylinder::domHeight(dae); + return ref; +} + + +daeMetaElement * +domTapered_cylinder::domHeight::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "height" ); + meta->registerClass(domTapered_cylinder::domHeight::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domTapered_cylinder::domHeight , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domTapered_cylinder::domHeight)); + meta->validate(); + + return meta; +} + +daeElementRef +domTapered_cylinder::domRadius1::create(DAE& dae) +{ + domTapered_cylinder::domRadius1Ref ref = new domTapered_cylinder::domRadius1(dae); + return ref; +} + + +daeMetaElement * +domTapered_cylinder::domRadius1::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "radius1" ); + meta->registerClass(domTapered_cylinder::domRadius1::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domTapered_cylinder::domRadius1 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domTapered_cylinder::domRadius1)); + meta->validate(); + + return meta; +} + +daeElementRef +domTapered_cylinder::domRadius2::create(DAE& dae) +{ + domTapered_cylinder::domRadius2Ref ref = new domTapered_cylinder::domRadius2(dae); + return ref; +} + + +daeMetaElement * +domTapered_cylinder::domRadius2::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "radius2" ); + meta->registerClass(domTapered_cylinder::domRadius2::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float2")); + ma->setOffset( daeOffsetOf( domTapered_cylinder::domRadius2 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domTapered_cylinder::domRadius2)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domTargetableFloat.cpp b/1.4.0/dom/src/1.4/dom/domTargetableFloat.cpp new file mode 100644 index 0000000..db259c4 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domTargetableFloat.cpp @@ -0,0 +1,67 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domTargetableFloat.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domTargetableFloat::create(DAE& dae) +{ + domTargetableFloatRef ref = new domTargetableFloat(dae); + return ref; +} + + +daeMetaElement * +domTargetableFloat::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "TargetableFloat" ); + meta->registerClass(domTargetableFloat::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float")); + ma->setOffset( daeOffsetOf( domTargetableFloat , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domTargetableFloat , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domTargetableFloat)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domTargetableFloat3.cpp b/1.4.0/dom/src/1.4/dom/domTargetableFloat3.cpp new file mode 100644 index 0000000..a181895 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domTargetableFloat3.cpp @@ -0,0 +1,67 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domTargetableFloat3.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domTargetableFloat3::create(DAE& dae) +{ + domTargetableFloat3Ref ref = new domTargetableFloat3(dae); + return ref; +} + + +daeMetaElement * +domTargetableFloat3::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "TargetableFloat3" ); + meta->registerClass(domTargetableFloat3::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domTargetableFloat3 , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domTargetableFloat3 , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domTargetableFloat3)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domTechnique.cpp b/1.4.0/dom/src/1.4/dom/domTechnique.cpp new file mode 100644 index 0000000..6a2762a --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domTechnique.cpp @@ -0,0 +1,85 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domTechnique.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domTechnique::create(DAE& dae) +{ + domTechniqueRef ref = new domTechnique(dae); + return ref; +} + + +daeMetaElement * +domTechnique::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "technique" ); + meta->registerClass(domTechnique::create); + + daeMetaCMPolicy *cm = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + cm = new daeMetaAny( meta, cm, 0, 0, -1 ); + + cm->setMaxOrdinal( 0 ); + cm->getParent()->appendChild( cm ); + cm = cm->getParent(); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + meta->setAllowsAny( true ); + // Ordered list of sub-elements + meta->addContents(daeOffsetOf(domTechnique,_contents)); + meta->addContentsOrder(daeOffsetOf(domTechnique,_contentsOrder)); + + // Add attribute: xmlns + { + daeMetaAttribute* ma = new daeMetaAttribute; + ma->setName( "xmlns" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domTechnique , attrXmlns )); + ma->setContainer( meta ); + //ma->setIsRequired( true ); + meta->appendAttribute(ma); + } + + // Add attribute: profile + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "profile" ); + ma->setType( dae.getAtomicTypes().get("xsNMTOKEN")); + ma->setOffset( daeOffsetOf( domTechnique , attrProfile )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domTechnique)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domTranslate.cpp b/1.4.0/dom/src/1.4/dom/domTranslate.cpp new file mode 100644 index 0000000..90b968b --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domTranslate.cpp @@ -0,0 +1,67 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domTranslate.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domTranslate::create(DAE& dae) +{ + domTranslateRef ref = new domTranslate(dae); + return ref; +} + + +daeMetaElement * +domTranslate::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "translate" ); + meta->registerClass(domTranslate::create); + + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaArrayAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("Float3")); + ma->setOffset( daeOffsetOf( domTranslate , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + // Add attribute: sid + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "sid" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domTranslate , attrSid )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domTranslate)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domTriangles.cpp b/1.4.0/dom/src/1.4/dom/domTriangles.cpp new file mode 100644 index 0000000..b4005f3 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domTriangles.cpp @@ -0,0 +1,105 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domTriangles.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domTriangles::create(DAE& dae) +{ + domTrianglesRef ref = new domTriangles(dae); + return ref; +} + + +daeMetaElement * +domTriangles::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "triangles" ); + meta->registerClass(domTriangles::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "input" ); + mea->setOffset( daeOffsetOf(domTriangles,elemInput_array) ); + mea->setElementType( domInputLocalOffset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "p" ); + mea->setOffset( daeOffsetOf(domTriangles,elemP) ); + mea->setElementType( domP::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domTriangles,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domTriangles , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: count + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "count" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domTriangles , attrCount )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: material + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "material" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domTriangles , attrMaterial )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domTriangles)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domTrifans.cpp b/1.4.0/dom/src/1.4/dom/domTrifans.cpp new file mode 100644 index 0000000..240d855 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domTrifans.cpp @@ -0,0 +1,105 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domTrifans.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domTrifans::create(DAE& dae) +{ + domTrifansRef ref = new domTrifans(dae); + return ref; +} + + +daeMetaElement * +domTrifans::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "trifans" ); + meta->registerClass(domTrifans::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "input" ); + mea->setOffset( daeOffsetOf(domTrifans,elemInput_array) ); + mea->setElementType( domInputLocalOffset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "p" ); + mea->setOffset( daeOffsetOf(domTrifans,elemP_array) ); + mea->setElementType( domP::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domTrifans,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domTrifans , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: count + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "count" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domTrifans , attrCount )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: material + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "material" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domTrifans , attrMaterial )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domTrifans)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domTristrips.cpp b/1.4.0/dom/src/1.4/dom/domTristrips.cpp new file mode 100644 index 0000000..4acfdf9 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domTristrips.cpp @@ -0,0 +1,105 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domTristrips.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domTristrips::create(DAE& dae) +{ + domTristripsRef ref = new domTristrips(dae); + return ref; +} + + +daeMetaElement * +domTristrips::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "tristrips" ); + meta->registerClass(domTristrips::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "input" ); + mea->setOffset( daeOffsetOf(domTristrips,elemInput_array) ); + mea->setElementType( domInputLocalOffset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "p" ); + mea->setOffset( daeOffsetOf(domTristrips,elemP_array) ); + mea->setElementType( domP::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domTristrips,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 2 ); + meta->setCMRoot( cm ); + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domTristrips , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + // Add attribute: count + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "count" ); + ma->setType( dae.getAtomicTypes().get("Uint")); + ma->setOffset( daeOffsetOf( domTristrips , attrCount )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: material + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "material" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domTristrips , attrMaterial )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domTristrips)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domTypes.cpp b/1.4.0/dom/src/1.4/dom/domTypes.cpp new file mode 100644 index 0000000..175e697 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domTypes.cpp @@ -0,0 +1,2940 @@ +/* + * Copyright 2006 Sony Computer Entertainment Inc. + * + * Licensed under the MIT Open Source License, for details please see license.txt or the website + * http://www.opensource.org/licenses/mit-license.php + * + */ + +#include <dae.h> +#include <1.4/dom/domTypes.h> +#include <dae/daeDom.h> +#include <1.4/dom/domCOLLADA.h> + +namespace ColladaDOM141 { + +void registerDomTypes(DAE& dae) +{ + daeAtomicType* type = NULL; + daeAtomicTypeList& atomicTypes = dae.getAtomicTypes(); + + // TYPEDEF: Bool //check if this type has an existing base + type = atomicTypes.get("xsBoolean"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Bool"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Bool"); + } + + // TYPEDEF: DateTime //check if this type has an existing base + type = atomicTypes.get("xsDateTime"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("DateTime"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("DateTime"); + } + + // TYPEDEF: Float //check if this type has an existing base + type = atomicTypes.get("xsDouble"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Float"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Float"); + } + + // TYPEDEF: Int //check if this type has an existing base + type = atomicTypes.get("xsLong"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Int"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Int"); + } + + // TYPEDEF: Name //check if this type has an existing base + type = atomicTypes.get("xsName"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Name"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Name"); + } + + // TYPEDEF: String //check if this type has an existing base + type = atomicTypes.get("xsString"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("String"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("String"); + } + + // TYPEDEF: Token //check if this type has an existing base + type = atomicTypes.get("xsToken"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Token"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Token"); + } + + // TYPEDEF: Uint //check if this type has an existing base + type = atomicTypes.get("xsUnsignedLong"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Uint"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Uint"); + } + + // TYPEDEF: ListOfBools //check if this type has an existing base + type = atomicTypes.get("Bool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("ListOfBools"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("ListOfBools"); + } + + // TYPEDEF: ListOfFloats //check if this type has an existing base + type = atomicTypes.get("Float"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("ListOfFloats"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("ListOfFloats"); + } + + // TYPEDEF: ListOfHexBinary //check if this type has an existing base + type = atomicTypes.get("xsHexBinary"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("ListOfHexBinary"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("ListOfHexBinary"); + } + + // TYPEDEF: ListOfInts //check if this type has an existing base + type = atomicTypes.get("Int"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("ListOfInts"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("ListOfInts"); + } + + // TYPEDEF: ListOfNames //check if this type has an existing base + type = atomicTypes.get("Name"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("ListOfNames"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("ListOfNames"); + } + + // TYPEDEF: ListOfTokens //check if this type has an existing base + type = atomicTypes.get("Token"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("ListOfTokens"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("ListOfTokens"); + } + + // TYPEDEF: ListOfUInts //check if this type has an existing base + type = atomicTypes.get("Uint"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("ListOfUInts"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("ListOfUInts"); + } + + // TYPEDEF: Bool2 //check if this type has an existing base + type = atomicTypes.get("ListOfBools"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Bool2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Bool2"); + } + + // TYPEDEF: Bool3 //check if this type has an existing base + type = atomicTypes.get("ListOfBools"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Bool3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Bool3"); + } + + // TYPEDEF: Bool4 //check if this type has an existing base + type = atomicTypes.get("ListOfBools"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Bool4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Bool4"); + } + + // TYPEDEF: Float2 //check if this type has an existing base + type = atomicTypes.get("ListOfFloats"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Float2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Float2"); + } + + // TYPEDEF: Float3 //check if this type has an existing base + type = atomicTypes.get("ListOfFloats"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Float3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Float3"); + } + + // TYPEDEF: Float4 //check if this type has an existing base + type = atomicTypes.get("ListOfFloats"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Float4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Float4"); + } + + // TYPEDEF: Float7 //check if this type has an existing base + type = atomicTypes.get("ListOfFloats"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Float7"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Float7"); + } + + // TYPEDEF: Float2x2 //check if this type has an existing base + type = atomicTypes.get("ListOfFloats"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Float2x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Float2x2"); + } + + // TYPEDEF: Float3x3 //check if this type has an existing base + type = atomicTypes.get("ListOfFloats"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Float3x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Float3x3"); + } + + // TYPEDEF: Float4x4 //check if this type has an existing base + type = atomicTypes.get("ListOfFloats"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Float4x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Float4x4"); + } + + // TYPEDEF: Float2x3 //check if this type has an existing base + type = atomicTypes.get("ListOfFloats"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Float2x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Float2x3"); + } + + // TYPEDEF: Float2x4 //check if this type has an existing base + type = atomicTypes.get("ListOfFloats"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Float2x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Float2x4"); + } + + // TYPEDEF: Float3x2 //check if this type has an existing base + type = atomicTypes.get("ListOfFloats"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Float3x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Float3x2"); + } + + // TYPEDEF: Float3x4 //check if this type has an existing base + type = atomicTypes.get("ListOfFloats"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Float3x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Float3x4"); + } + + // TYPEDEF: Float4x2 //check if this type has an existing base + type = atomicTypes.get("ListOfFloats"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Float4x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Float4x2"); + } + + // TYPEDEF: Float4x3 //check if this type has an existing base + type = atomicTypes.get("ListOfFloats"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Float4x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Float4x3"); + } + + // TYPEDEF: Int2 //check if this type has an existing base + type = atomicTypes.get("ListOfInts"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Int2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Int2"); + } + + // TYPEDEF: Int3 //check if this type has an existing base + type = atomicTypes.get("ListOfInts"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Int3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Int3"); + } + + // TYPEDEF: Int4 //check if this type has an existing base + type = atomicTypes.get("ListOfInts"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Int4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Int4"); + } + + // TYPEDEF: Int2x2 //check if this type has an existing base + type = atomicTypes.get("ListOfInts"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Int2x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Int2x2"); + } + + // TYPEDEF: Int3x3 //check if this type has an existing base + type = atomicTypes.get("ListOfInts"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Int3x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Int3x3"); + } + + // TYPEDEF: Int4x4 //check if this type has an existing base + type = atomicTypes.get("ListOfInts"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Int4x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Int4x4"); + } + + // ENUM: MorphMethodType + type = new daeEnumType(dae); + type->_nameBindings.append("MorphMethodType"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("NORMALIZED"); + ((daeEnumType*)type)->_values->append(MORPHMETHODTYPE_NORMALIZED); + ((daeEnumType*)type)->_strings->append("RELATIVE"); + ((daeEnumType*)type)->_values->append(MORPHMETHODTYPE_RELATIVE); + atomicTypes.append( type ); + + // ENUM: NodeType + type = new daeEnumType(dae); + type->_nameBindings.append("NodeType"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("JOINT"); + ((daeEnumType*)type)->_values->append(NODETYPE_JOINT); + ((daeEnumType*)type)->_strings->append("NODE"); + ((daeEnumType*)type)->_values->append(NODETYPE_NODE); + atomicTypes.append( type ); + + // TYPEDEF: URIFragmentType //check if this type has an existing base + type = atomicTypes.get("xsAnyURI"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("URIFragmentType"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("URIFragmentType"); + } + + // ENUM: UpAxisType + type = new daeEnumType(dae); + type->_nameBindings.append("UpAxisType"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("X_UP"); + ((daeEnumType*)type)->_values->append(UPAXISTYPE_X_UP); + ((daeEnumType*)type)->_strings->append("Y_UP"); + ((daeEnumType*)type)->_values->append(UPAXISTYPE_Y_UP); + ((daeEnumType*)type)->_strings->append("Z_UP"); + ((daeEnumType*)type)->_values->append(UPAXISTYPE_Z_UP); + atomicTypes.append( type ); + + // ENUM: VersionType + type = new daeEnumType(dae); + type->_nameBindings.append("VersionType"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("1.4.0"); + ((daeEnumType*)type)->_values->append(VERSIONTYPE_1_4_0); + ((daeEnumType*)type)->_strings->append("1.4.1"); + ((daeEnumType*)type)->_values->append(VERSIONTYPE_1_4_1); + atomicTypes.append( type ); + + // TYPEDEF: Fx_color_common //check if this type has an existing base + type = atomicTypes.get("Float4"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Fx_color_common"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Fx_color_common"); + } + + // ENUM: Fx_opaque_enum + type = new daeEnumType(dae); + type->_nameBindings.append("Fx_opaque_enum"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("A_ONE"); + ((daeEnumType*)type)->_values->append(FX_OPAQUE_ENUM_A_ONE); + ((daeEnumType*)type)->_strings->append("RGB_ZERO"); + ((daeEnumType*)type)->_values->append(FX_OPAQUE_ENUM_RGB_ZERO); + atomicTypes.append( type ); + + // ENUM: Fx_surface_type_enum + type = new daeEnumType(dae); + type->_nameBindings.append("Fx_surface_type_enum"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("UNTYPED"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_TYPE_ENUM_UNTYPED); + ((daeEnumType*)type)->_strings->append("1D"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_TYPE_ENUM_1D); + ((daeEnumType*)type)->_strings->append("2D"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_TYPE_ENUM_2D); + ((daeEnumType*)type)->_strings->append("3D"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_TYPE_ENUM_3D); + ((daeEnumType*)type)->_strings->append("RECT"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_TYPE_ENUM_RECT); + ((daeEnumType*)type)->_strings->append("CUBE"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_TYPE_ENUM_CUBE); + ((daeEnumType*)type)->_strings->append("DEPTH"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_TYPE_ENUM_DEPTH); + atomicTypes.append( type ); + + // ENUM: Fx_surface_face_enum + type = new daeEnumType(dae); + type->_nameBindings.append("Fx_surface_face_enum"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("POSITIVE_X"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FACE_ENUM_POSITIVE_X); + ((daeEnumType*)type)->_strings->append("NEGATIVE_X"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FACE_ENUM_NEGATIVE_X); + ((daeEnumType*)type)->_strings->append("POSITIVE_Y"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FACE_ENUM_POSITIVE_Y); + ((daeEnumType*)type)->_strings->append("NEGATIVE_Y"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FACE_ENUM_NEGATIVE_Y); + ((daeEnumType*)type)->_strings->append("POSITIVE_Z"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FACE_ENUM_POSITIVE_Z); + ((daeEnumType*)type)->_strings->append("NEGATIVE_Z"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FACE_ENUM_NEGATIVE_Z); + atomicTypes.append( type ); + + // ENUM: Fx_surface_format_hint_channels_enum + type = new daeEnumType(dae); + type->_nameBindings.append("Fx_surface_format_hint_channels_enum"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("RGB"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_CHANNELS_ENUM_RGB); + ((daeEnumType*)type)->_strings->append("RGBA"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_CHANNELS_ENUM_RGBA); + ((daeEnumType*)type)->_strings->append("L"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_CHANNELS_ENUM_L); + ((daeEnumType*)type)->_strings->append("LA"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_CHANNELS_ENUM_LA); + ((daeEnumType*)type)->_strings->append("D"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_CHANNELS_ENUM_D); + ((daeEnumType*)type)->_strings->append("XYZ"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_CHANNELS_ENUM_XYZ); + ((daeEnumType*)type)->_strings->append("XYZW"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_CHANNELS_ENUM_XYZW); + atomicTypes.append( type ); + + // ENUM: Fx_surface_format_hint_precision_enum + type = new daeEnumType(dae); + type->_nameBindings.append("Fx_surface_format_hint_precision_enum"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("LOW"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_PRECISION_ENUM_LOW); + ((daeEnumType*)type)->_strings->append("MID"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_PRECISION_ENUM_MID); + ((daeEnumType*)type)->_strings->append("HIGH"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_PRECISION_ENUM_HIGH); + atomicTypes.append( type ); + + // ENUM: Fx_surface_format_hint_range_enum + type = new daeEnumType(dae); + type->_nameBindings.append("Fx_surface_format_hint_range_enum"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("SNORM"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_RANGE_ENUM_SNORM); + ((daeEnumType*)type)->_strings->append("UNORM"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_RANGE_ENUM_UNORM); + ((daeEnumType*)type)->_strings->append("SINT"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_RANGE_ENUM_SINT); + ((daeEnumType*)type)->_strings->append("UINT"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_RANGE_ENUM_UINT); + ((daeEnumType*)type)->_strings->append("FLOAT"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_RANGE_ENUM_FLOAT); + atomicTypes.append( type ); + + // ENUM: Fx_surface_format_hint_option_enum + type = new daeEnumType(dae); + type->_nameBindings.append("Fx_surface_format_hint_option_enum"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("SRGB_GAMMA"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_OPTION_ENUM_SRGB_GAMMA); + ((daeEnumType*)type)->_strings->append("NORMALIZED3"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_OPTION_ENUM_NORMALIZED3); + ((daeEnumType*)type)->_strings->append("NORMALIZED4"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_OPTION_ENUM_NORMALIZED4); + ((daeEnumType*)type)->_strings->append("COMPRESSABLE"); + ((daeEnumType*)type)->_values->append(FX_SURFACE_FORMAT_HINT_OPTION_ENUM_COMPRESSABLE); + atomicTypes.append( type ); + + // ENUM: Fx_sampler_wrap_common + type = new daeEnumType(dae); + type->_nameBindings.append("Fx_sampler_wrap_common"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("NONE"); + ((daeEnumType*)type)->_values->append(FX_SAMPLER_WRAP_COMMON_NONE); + ((daeEnumType*)type)->_strings->append("WRAP"); + ((daeEnumType*)type)->_values->append(FX_SAMPLER_WRAP_COMMON_WRAP); + ((daeEnumType*)type)->_strings->append("MIRROR"); + ((daeEnumType*)type)->_values->append(FX_SAMPLER_WRAP_COMMON_MIRROR); + ((daeEnumType*)type)->_strings->append("CLAMP"); + ((daeEnumType*)type)->_values->append(FX_SAMPLER_WRAP_COMMON_CLAMP); + ((daeEnumType*)type)->_strings->append("BORDER"); + ((daeEnumType*)type)->_values->append(FX_SAMPLER_WRAP_COMMON_BORDER); + atomicTypes.append( type ); + + // ENUM: Fx_sampler_filter_common + type = new daeEnumType(dae); + type->_nameBindings.append("Fx_sampler_filter_common"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("NONE"); + ((daeEnumType*)type)->_values->append(FX_SAMPLER_FILTER_COMMON_NONE); + ((daeEnumType*)type)->_strings->append("NEAREST"); + ((daeEnumType*)type)->_values->append(FX_SAMPLER_FILTER_COMMON_NEAREST); + ((daeEnumType*)type)->_strings->append("LINEAR"); + ((daeEnumType*)type)->_values->append(FX_SAMPLER_FILTER_COMMON_LINEAR); + ((daeEnumType*)type)->_strings->append("NEAREST_MIPMAP_NEAREST"); + ((daeEnumType*)type)->_values->append(FX_SAMPLER_FILTER_COMMON_NEAREST_MIPMAP_NEAREST); + ((daeEnumType*)type)->_strings->append("LINEAR_MIPMAP_NEAREST"); + ((daeEnumType*)type)->_values->append(FX_SAMPLER_FILTER_COMMON_LINEAR_MIPMAP_NEAREST); + ((daeEnumType*)type)->_strings->append("NEAREST_MIPMAP_LINEAR"); + ((daeEnumType*)type)->_values->append(FX_SAMPLER_FILTER_COMMON_NEAREST_MIPMAP_LINEAR); + ((daeEnumType*)type)->_strings->append("LINEAR_MIPMAP_LINEAR"); + ((daeEnumType*)type)->_values->append(FX_SAMPLER_FILTER_COMMON_LINEAR_MIPMAP_LINEAR); + atomicTypes.append( type ); + + // ENUM: Fx_modifier_enum_common + type = new daeEnumType(dae); + type->_nameBindings.append("Fx_modifier_enum_common"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("CONST"); + ((daeEnumType*)type)->_values->append(FX_MODIFIER_ENUM_COMMON_CONST); + ((daeEnumType*)type)->_strings->append("UNIFORM"); + ((daeEnumType*)type)->_values->append(FX_MODIFIER_ENUM_COMMON_UNIFORM); + ((daeEnumType*)type)->_strings->append("VARYING"); + ((daeEnumType*)type)->_values->append(FX_MODIFIER_ENUM_COMMON_VARYING); + ((daeEnumType*)type)->_strings->append("STATIC"); + ((daeEnumType*)type)->_values->append(FX_MODIFIER_ENUM_COMMON_STATIC); + ((daeEnumType*)type)->_strings->append("VOLATILE"); + ((daeEnumType*)type)->_values->append(FX_MODIFIER_ENUM_COMMON_VOLATILE); + ((daeEnumType*)type)->_strings->append("EXTERN"); + ((daeEnumType*)type)->_values->append(FX_MODIFIER_ENUM_COMMON_EXTERN); + ((daeEnumType*)type)->_strings->append("SHARED"); + ((daeEnumType*)type)->_values->append(FX_MODIFIER_ENUM_COMMON_SHARED); + atomicTypes.append( type ); + + // TYPEDEF: Fx_draw_common //check if this type has an existing base + type = atomicTypes.get("xsString"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Fx_draw_common"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Fx_draw_common"); + } + + // ENUM: Fx_pipeline_stage_common + type = new daeEnumType(dae); + type->_nameBindings.append("Fx_pipeline_stage_common"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("VERTEXPROGRAM"); + ((daeEnumType*)type)->_values->append(FX_PIPELINE_STAGE_COMMON_VERTEXPROGRAM); + ((daeEnumType*)type)->_strings->append("FRAGMENTPROGRAM"); + ((daeEnumType*)type)->_values->append(FX_PIPELINE_STAGE_COMMON_FRAGMENTPROGRAM); + ((daeEnumType*)type)->_strings->append("VERTEXSHADER"); + ((daeEnumType*)type)->_values->append(FX_PIPELINE_STAGE_COMMON_VERTEXSHADER); + ((daeEnumType*)type)->_strings->append("PIXELSHADER"); + ((daeEnumType*)type)->_values->append(FX_PIPELINE_STAGE_COMMON_PIXELSHADER); + atomicTypes.append( type ); + + // TYPEDEF: GL_MAX_LIGHTS_index //check if this type has an existing base + type = atomicTypes.get("xsNonNegativeInteger"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("GL_MAX_LIGHTS_index"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("GL_MAX_LIGHTS_index"); + } + + // TYPEDEF: GL_MAX_CLIP_PLANES_index //check if this type has an existing base + type = atomicTypes.get("xsNonNegativeInteger"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("GL_MAX_CLIP_PLANES_index"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("GL_MAX_CLIP_PLANES_index"); + } + + // TYPEDEF: GL_MAX_TEXTURE_IMAGE_UNITS_index //check if this type has an existing base + type = atomicTypes.get("xsNonNegativeInteger"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("GL_MAX_TEXTURE_IMAGE_UNITS_index"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("GL_MAX_TEXTURE_IMAGE_UNITS_index"); + } + + // ENUM: Gl_blend_type + type = new daeEnumType(dae); + type->_nameBindings.append("Gl_blend_type"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("ZERO"); + ((daeEnumType*)type)->_values->append(GL_BLEND_TYPE_ZERO); + ((daeEnumType*)type)->_strings->append("ONE"); + ((daeEnumType*)type)->_values->append(GL_BLEND_TYPE_ONE); + ((daeEnumType*)type)->_strings->append("SRC_COLOR"); + ((daeEnumType*)type)->_values->append(GL_BLEND_TYPE_SRC_COLOR); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_SRC_COLOR"); + ((daeEnumType*)type)->_values->append(GL_BLEND_TYPE_ONE_MINUS_SRC_COLOR); + ((daeEnumType*)type)->_strings->append("DEST_COLOR"); + ((daeEnumType*)type)->_values->append(GL_BLEND_TYPE_DEST_COLOR); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_DEST_COLOR"); + ((daeEnumType*)type)->_values->append(GL_BLEND_TYPE_ONE_MINUS_DEST_COLOR); + ((daeEnumType*)type)->_strings->append("SRC_ALPHA"); + ((daeEnumType*)type)->_values->append(GL_BLEND_TYPE_SRC_ALPHA); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_SRC_ALPHA"); + ((daeEnumType*)type)->_values->append(GL_BLEND_TYPE_ONE_MINUS_SRC_ALPHA); + ((daeEnumType*)type)->_strings->append("DST_ALPHA"); + ((daeEnumType*)type)->_values->append(GL_BLEND_TYPE_DST_ALPHA); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_DST_ALPHA"); + ((daeEnumType*)type)->_values->append(GL_BLEND_TYPE_ONE_MINUS_DST_ALPHA); + ((daeEnumType*)type)->_strings->append("CONSTANT_COLOR"); + ((daeEnumType*)type)->_values->append(GL_BLEND_TYPE_CONSTANT_COLOR); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_CONSTANT_COLOR"); + ((daeEnumType*)type)->_values->append(GL_BLEND_TYPE_ONE_MINUS_CONSTANT_COLOR); + ((daeEnumType*)type)->_strings->append("CONSTANT_ALPHA"); + ((daeEnumType*)type)->_values->append(GL_BLEND_TYPE_CONSTANT_ALPHA); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_CONSTANT_ALPHA"); + ((daeEnumType*)type)->_values->append(GL_BLEND_TYPE_ONE_MINUS_CONSTANT_ALPHA); + ((daeEnumType*)type)->_strings->append("SRC_ALPHA_SATURATE"); + ((daeEnumType*)type)->_values->append(GL_BLEND_TYPE_SRC_ALPHA_SATURATE); + atomicTypes.append( type ); + + // ENUM: Gl_face_type + type = new daeEnumType(dae); + type->_nameBindings.append("Gl_face_type"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("FRONT"); + ((daeEnumType*)type)->_values->append(GL_FACE_TYPE_FRONT); + ((daeEnumType*)type)->_strings->append("BACK"); + ((daeEnumType*)type)->_values->append(GL_FACE_TYPE_BACK); + ((daeEnumType*)type)->_strings->append("FRONT_AND_BACK"); + ((daeEnumType*)type)->_values->append(GL_FACE_TYPE_FRONT_AND_BACK); + atomicTypes.append( type ); + + // ENUM: Gl_blend_equation_type + type = new daeEnumType(dae); + type->_nameBindings.append("Gl_blend_equation_type"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("FUNC_ADD"); + ((daeEnumType*)type)->_values->append(GL_BLEND_EQUATION_TYPE_FUNC_ADD); + ((daeEnumType*)type)->_strings->append("FUNC_SUBTRACT"); + ((daeEnumType*)type)->_values->append(GL_BLEND_EQUATION_TYPE_FUNC_SUBTRACT); + ((daeEnumType*)type)->_strings->append("FUNC_REVERSE_SUBTRACT"); + ((daeEnumType*)type)->_values->append(GL_BLEND_EQUATION_TYPE_FUNC_REVERSE_SUBTRACT); + ((daeEnumType*)type)->_strings->append("MIN"); + ((daeEnumType*)type)->_values->append(GL_BLEND_EQUATION_TYPE_MIN); + ((daeEnumType*)type)->_strings->append("MAX"); + ((daeEnumType*)type)->_values->append(GL_BLEND_EQUATION_TYPE_MAX); + atomicTypes.append( type ); + + // ENUM: Gl_func_type + type = new daeEnumType(dae); + type->_nameBindings.append("Gl_func_type"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("NEVER"); + ((daeEnumType*)type)->_values->append(GL_FUNC_TYPE_NEVER); + ((daeEnumType*)type)->_strings->append("LESS"); + ((daeEnumType*)type)->_values->append(GL_FUNC_TYPE_LESS); + ((daeEnumType*)type)->_strings->append("LEQUAL"); + ((daeEnumType*)type)->_values->append(GL_FUNC_TYPE_LEQUAL); + ((daeEnumType*)type)->_strings->append("EQUAL"); + ((daeEnumType*)type)->_values->append(GL_FUNC_TYPE_EQUAL); + ((daeEnumType*)type)->_strings->append("GREATER"); + ((daeEnumType*)type)->_values->append(GL_FUNC_TYPE_GREATER); + ((daeEnumType*)type)->_strings->append("NOTEQUAL"); + ((daeEnumType*)type)->_values->append(GL_FUNC_TYPE_NOTEQUAL); + ((daeEnumType*)type)->_strings->append("GEQUAL"); + ((daeEnumType*)type)->_values->append(GL_FUNC_TYPE_GEQUAL); + ((daeEnumType*)type)->_strings->append("ALWAYS"); + ((daeEnumType*)type)->_values->append(GL_FUNC_TYPE_ALWAYS); + atomicTypes.append( type ); + + // ENUM: Gl_stencil_op_type + type = new daeEnumType(dae); + type->_nameBindings.append("Gl_stencil_op_type"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("KEEP"); + ((daeEnumType*)type)->_values->append(GL_STENCIL_OP_TYPE_KEEP); + ((daeEnumType*)type)->_strings->append("ZERO"); + ((daeEnumType*)type)->_values->append(GL_STENCIL_OP_TYPE_ZERO); + ((daeEnumType*)type)->_strings->append("REPLACE"); + ((daeEnumType*)type)->_values->append(GL_STENCIL_OP_TYPE_REPLACE); + ((daeEnumType*)type)->_strings->append("INCR"); + ((daeEnumType*)type)->_values->append(GL_STENCIL_OP_TYPE_INCR); + ((daeEnumType*)type)->_strings->append("DECR"); + ((daeEnumType*)type)->_values->append(GL_STENCIL_OP_TYPE_DECR); + ((daeEnumType*)type)->_strings->append("INVERT"); + ((daeEnumType*)type)->_values->append(GL_STENCIL_OP_TYPE_INVERT); + ((daeEnumType*)type)->_strings->append("INCR_WRAP"); + ((daeEnumType*)type)->_values->append(GL_STENCIL_OP_TYPE_INCR_WRAP); + ((daeEnumType*)type)->_strings->append("DECR_WRAP"); + ((daeEnumType*)type)->_values->append(GL_STENCIL_OP_TYPE_DECR_WRAP); + atomicTypes.append( type ); + + // ENUM: Gl_material_type + type = new daeEnumType(dae); + type->_nameBindings.append("Gl_material_type"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("EMISSION"); + ((daeEnumType*)type)->_values->append(GL_MATERIAL_TYPE_EMISSION); + ((daeEnumType*)type)->_strings->append("AMBIENT"); + ((daeEnumType*)type)->_values->append(GL_MATERIAL_TYPE_AMBIENT); + ((daeEnumType*)type)->_strings->append("DIFFUSE"); + ((daeEnumType*)type)->_values->append(GL_MATERIAL_TYPE_DIFFUSE); + ((daeEnumType*)type)->_strings->append("SPECULAR"); + ((daeEnumType*)type)->_values->append(GL_MATERIAL_TYPE_SPECULAR); + ((daeEnumType*)type)->_strings->append("AMBIENT_AND_DIFFUSE"); + ((daeEnumType*)type)->_values->append(GL_MATERIAL_TYPE_AMBIENT_AND_DIFFUSE); + atomicTypes.append( type ); + + // ENUM: Gl_fog_type + type = new daeEnumType(dae); + type->_nameBindings.append("Gl_fog_type"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("LINEAR"); + ((daeEnumType*)type)->_values->append(GL_FOG_TYPE_LINEAR); + ((daeEnumType*)type)->_strings->append("EXP"); + ((daeEnumType*)type)->_values->append(GL_FOG_TYPE_EXP); + ((daeEnumType*)type)->_strings->append("EXP2"); + ((daeEnumType*)type)->_values->append(GL_FOG_TYPE_EXP2); + atomicTypes.append( type ); + + // ENUM: Gl_fog_coord_src_type + type = new daeEnumType(dae); + type->_nameBindings.append("Gl_fog_coord_src_type"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("FOG_COORDINATE"); + ((daeEnumType*)type)->_values->append(GL_FOG_COORD_SRC_TYPE_FOG_COORDINATE); + ((daeEnumType*)type)->_strings->append("FRAGMENT_DEPTH"); + ((daeEnumType*)type)->_values->append(GL_FOG_COORD_SRC_TYPE_FRAGMENT_DEPTH); + atomicTypes.append( type ); + + // ENUM: Gl_front_face_type + type = new daeEnumType(dae); + type->_nameBindings.append("Gl_front_face_type"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("CW"); + ((daeEnumType*)type)->_values->append(GL_FRONT_FACE_TYPE_CW); + ((daeEnumType*)type)->_strings->append("CCW"); + ((daeEnumType*)type)->_values->append(GL_FRONT_FACE_TYPE_CCW); + atomicTypes.append( type ); + + // ENUM: Gl_light_model_color_control_type + type = new daeEnumType(dae); + type->_nameBindings.append("Gl_light_model_color_control_type"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("SINGLE_COLOR"); + ((daeEnumType*)type)->_values->append(GL_LIGHT_MODEL_COLOR_CONTROL_TYPE_SINGLE_COLOR); + ((daeEnumType*)type)->_strings->append("SEPARATE_SPECULAR_COLOR"); + ((daeEnumType*)type)->_values->append(GL_LIGHT_MODEL_COLOR_CONTROL_TYPE_SEPARATE_SPECULAR_COLOR); + atomicTypes.append( type ); + + // ENUM: Gl_logic_op_type + type = new daeEnumType(dae); + type->_nameBindings.append("Gl_logic_op_type"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("CLEAR"); + ((daeEnumType*)type)->_values->append(GL_LOGIC_OP_TYPE_CLEAR); + ((daeEnumType*)type)->_strings->append("AND"); + ((daeEnumType*)type)->_values->append(GL_LOGIC_OP_TYPE_AND); + ((daeEnumType*)type)->_strings->append("AND_REVERSE"); + ((daeEnumType*)type)->_values->append(GL_LOGIC_OP_TYPE_AND_REVERSE); + ((daeEnumType*)type)->_strings->append("COPY"); + ((daeEnumType*)type)->_values->append(GL_LOGIC_OP_TYPE_COPY); + ((daeEnumType*)type)->_strings->append("AND_INVERTED"); + ((daeEnumType*)type)->_values->append(GL_LOGIC_OP_TYPE_AND_INVERTED); + ((daeEnumType*)type)->_strings->append("NOOP"); + ((daeEnumType*)type)->_values->append(GL_LOGIC_OP_TYPE_NOOP); + ((daeEnumType*)type)->_strings->append("XOR"); + ((daeEnumType*)type)->_values->append(GL_LOGIC_OP_TYPE_XOR); + ((daeEnumType*)type)->_strings->append("OR"); + ((daeEnumType*)type)->_values->append(GL_LOGIC_OP_TYPE_OR); + ((daeEnumType*)type)->_strings->append("NOR"); + ((daeEnumType*)type)->_values->append(GL_LOGIC_OP_TYPE_NOR); + ((daeEnumType*)type)->_strings->append("EQUIV"); + ((daeEnumType*)type)->_values->append(GL_LOGIC_OP_TYPE_EQUIV); + ((daeEnumType*)type)->_strings->append("INVERT"); + ((daeEnumType*)type)->_values->append(GL_LOGIC_OP_TYPE_INVERT); + ((daeEnumType*)type)->_strings->append("OR_REVERSE"); + ((daeEnumType*)type)->_values->append(GL_LOGIC_OP_TYPE_OR_REVERSE); + ((daeEnumType*)type)->_strings->append("COPY_INVERTED"); + ((daeEnumType*)type)->_values->append(GL_LOGIC_OP_TYPE_COPY_INVERTED); + ((daeEnumType*)type)->_strings->append("NAND"); + ((daeEnumType*)type)->_values->append(GL_LOGIC_OP_TYPE_NAND); + ((daeEnumType*)type)->_strings->append("SET"); + ((daeEnumType*)type)->_values->append(GL_LOGIC_OP_TYPE_SET); + atomicTypes.append( type ); + + // ENUM: Gl_polygon_mode_type + type = new daeEnumType(dae); + type->_nameBindings.append("Gl_polygon_mode_type"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("POINT"); + ((daeEnumType*)type)->_values->append(GL_POLYGON_MODE_TYPE_POINT); + ((daeEnumType*)type)->_strings->append("LINE"); + ((daeEnumType*)type)->_values->append(GL_POLYGON_MODE_TYPE_LINE); + ((daeEnumType*)type)->_strings->append("FILL"); + ((daeEnumType*)type)->_values->append(GL_POLYGON_MODE_TYPE_FILL); + atomicTypes.append( type ); + + // ENUM: Gl_shade_model_type + type = new daeEnumType(dae); + type->_nameBindings.append("Gl_shade_model_type"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("FLAT"); + ((daeEnumType*)type)->_values->append(GL_SHADE_MODEL_TYPE_FLAT); + ((daeEnumType*)type)->_strings->append("SMOOTH"); + ((daeEnumType*)type)->_values->append(GL_SHADE_MODEL_TYPE_SMOOTH); + atomicTypes.append( type ); + + // TYPEDEF: Gl_alpha_value_type //check if this type has an existing base + type = atomicTypes.get("xsFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Gl_alpha_value_type"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Gl_alpha_value_type"); + } + + // ENUM: Gl_enumeration + type = new daeEnumType(dae); + type->_nameBindings.append("Gl_enumeration"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("ZERO"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_ZERO); + ((daeEnumType*)type)->_strings->append("ONE"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_ONE); + ((daeEnumType*)type)->_strings->append("SRC_COLOR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_SRC_COLOR); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_SRC_COLOR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_ONE_MINUS_SRC_COLOR); + ((daeEnumType*)type)->_strings->append("DEST_COLOR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_DEST_COLOR); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_DEST_COLOR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_ONE_MINUS_DEST_COLOR); + ((daeEnumType*)type)->_strings->append("SRC_ALPHA"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_SRC_ALPHA); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_SRC_ALPHA"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_ONE_MINUS_SRC_ALPHA); + ((daeEnumType*)type)->_strings->append("DST_ALPHA"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_DST_ALPHA); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_DST_ALPHA"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_ONE_MINUS_DST_ALPHA); + ((daeEnumType*)type)->_strings->append("CONSTANT_COLOR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_CONSTANT_COLOR); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_CONSTANT_COLOR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_ONE_MINUS_CONSTANT_COLOR); + ((daeEnumType*)type)->_strings->append("CONSTANT_ALPHA"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_CONSTANT_ALPHA); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_CONSTANT_ALPHA"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_ONE_MINUS_CONSTANT_ALPHA); + ((daeEnumType*)type)->_strings->append("SRC_ALPHA_SATURATE"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_SRC_ALPHA_SATURATE); + ((daeEnumType*)type)->_strings->append("FRONT"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_FRONT); + ((daeEnumType*)type)->_strings->append("BACK"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_BACK); + ((daeEnumType*)type)->_strings->append("FRONT_AND_BACK"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_FRONT_AND_BACK); + ((daeEnumType*)type)->_strings->append("FUNC_ADD"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_FUNC_ADD); + ((daeEnumType*)type)->_strings->append("FUNC_SUBTRACT"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_FUNC_SUBTRACT); + ((daeEnumType*)type)->_strings->append("FUNC_REVERSE_SUBTRACT"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_FUNC_REVERSE_SUBTRACT); + ((daeEnumType*)type)->_strings->append("MIN"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_MIN); + ((daeEnumType*)type)->_strings->append("MAX"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_MAX); + ((daeEnumType*)type)->_strings->append("NEVER"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_NEVER); + ((daeEnumType*)type)->_strings->append("LESS"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_LESS); + ((daeEnumType*)type)->_strings->append("LEQUAL"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_LEQUAL); + ((daeEnumType*)type)->_strings->append("EQUAL"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_EQUAL); + ((daeEnumType*)type)->_strings->append("GREATER"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_GREATER); + ((daeEnumType*)type)->_strings->append("NOTEQUAL"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_NOTEQUAL); + ((daeEnumType*)type)->_strings->append("GEQUAL"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_GEQUAL); + ((daeEnumType*)type)->_strings->append("ALWAYS"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_ALWAYS); + ((daeEnumType*)type)->_strings->append("KEEP"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_KEEP); + ((daeEnumType*)type)->_strings->append("REPLACE"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_REPLACE); + ((daeEnumType*)type)->_strings->append("INCR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_INCR); + ((daeEnumType*)type)->_strings->append("DECR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_DECR); + ((daeEnumType*)type)->_strings->append("INVERT"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_INVERT); + ((daeEnumType*)type)->_strings->append("INCR_WRAP"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_INCR_WRAP); + ((daeEnumType*)type)->_strings->append("DECR_WRAP"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_DECR_WRAP); + ((daeEnumType*)type)->_strings->append("EMISSION"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_EMISSION); + ((daeEnumType*)type)->_strings->append("AMBIENT"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_AMBIENT); + ((daeEnumType*)type)->_strings->append("DIFFUSE"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_DIFFUSE); + ((daeEnumType*)type)->_strings->append("SPECULAR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_SPECULAR); + ((daeEnumType*)type)->_strings->append("AMBIENT_AND_DIFFUSE"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_AMBIENT_AND_DIFFUSE); + ((daeEnumType*)type)->_strings->append("LINEAR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_LINEAR); + ((daeEnumType*)type)->_strings->append("EXP"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_EXP); + ((daeEnumType*)type)->_strings->append("EXP2"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_EXP2); + ((daeEnumType*)type)->_strings->append("FOG_COORDINATE"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_FOG_COORDINATE); + ((daeEnumType*)type)->_strings->append("FRAGMENT_DEPTH"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_FRAGMENT_DEPTH); + ((daeEnumType*)type)->_strings->append("CW"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_CW); + ((daeEnumType*)type)->_strings->append("CCW"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_CCW); + ((daeEnumType*)type)->_strings->append("SINGLE_COLOR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_SINGLE_COLOR); + ((daeEnumType*)type)->_strings->append("SEPARATE_SPECULAR_COLOR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_SEPARATE_SPECULAR_COLOR); + ((daeEnumType*)type)->_strings->append("CLEAR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_CLEAR); + ((daeEnumType*)type)->_strings->append("AND"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_AND); + ((daeEnumType*)type)->_strings->append("AND_REVERSE"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_AND_REVERSE); + ((daeEnumType*)type)->_strings->append("COPY"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_COPY); + ((daeEnumType*)type)->_strings->append("AND_INVERTED"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_AND_INVERTED); + ((daeEnumType*)type)->_strings->append("NOOP"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_NOOP); + ((daeEnumType*)type)->_strings->append("XOR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_XOR); + ((daeEnumType*)type)->_strings->append("OR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_OR); + ((daeEnumType*)type)->_strings->append("NOR"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_NOR); + ((daeEnumType*)type)->_strings->append("EQUIV"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_EQUIV); + ((daeEnumType*)type)->_strings->append("OR_REVERSE"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_OR_REVERSE); + ((daeEnumType*)type)->_strings->append("COPY_INVERTED"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_COPY_INVERTED); + ((daeEnumType*)type)->_strings->append("NAND"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_NAND); + ((daeEnumType*)type)->_strings->append("SET"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_SET); + ((daeEnumType*)type)->_strings->append("POINT"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_POINT); + ((daeEnumType*)type)->_strings->append("LINE"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_LINE); + ((daeEnumType*)type)->_strings->append("FILL"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_FILL); + ((daeEnumType*)type)->_strings->append("FLAT"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_FLAT); + ((daeEnumType*)type)->_strings->append("SMOOTH"); + ((daeEnumType*)type)->_values->append(GL_ENUMERATION_SMOOTH); + atomicTypes.append( type ); + + // TYPEDEF: Glsl_float //check if this type has an existing base + type = atomicTypes.get("xsFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_float"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_float"); + } + + // TYPEDEF: Glsl_int //check if this type has an existing base + type = atomicTypes.get("xsInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_int"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_int"); + } + + // TYPEDEF: Glsl_bool //check if this type has an existing base + type = atomicTypes.get("xsBoolean"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_bool"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_bool"); + } + + // TYPEDEF: Glsl_ListOfBool //check if this type has an existing base + type = atomicTypes.get("Glsl_bool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_ListOfBool"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_ListOfBool"); + } + + // TYPEDEF: Glsl_ListOfFloat //check if this type has an existing base + type = atomicTypes.get("Glsl_float"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_ListOfFloat"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_ListOfFloat"); + } + + // TYPEDEF: Glsl_ListOfInt //check if this type has an existing base + type = atomicTypes.get("Glsl_int"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_ListOfInt"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_ListOfInt"); + } + + // TYPEDEF: Glsl_bool2 //check if this type has an existing base + type = atomicTypes.get("Glsl_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_bool2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_bool2"); + } + + // TYPEDEF: Glsl_bool3 //check if this type has an existing base + type = atomicTypes.get("Glsl_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_bool3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_bool3"); + } + + // TYPEDEF: Glsl_bool4 //check if this type has an existing base + type = atomicTypes.get("Glsl_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_bool4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_bool4"); + } + + // TYPEDEF: Glsl_float2 //check if this type has an existing base + type = atomicTypes.get("Glsl_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_float2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_float2"); + } + + // TYPEDEF: Glsl_float3 //check if this type has an existing base + type = atomicTypes.get("Glsl_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_float3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_float3"); + } + + // TYPEDEF: Glsl_float4 //check if this type has an existing base + type = atomicTypes.get("Glsl_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_float4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_float4"); + } + + // TYPEDEF: Glsl_float2x2 //check if this type has an existing base + type = atomicTypes.get("Glsl_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_float2x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_float2x2"); + } + + // TYPEDEF: Glsl_float3x3 //check if this type has an existing base + type = atomicTypes.get("Glsl_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_float3x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_float3x3"); + } + + // TYPEDEF: Glsl_float4x4 //check if this type has an existing base + type = atomicTypes.get("Glsl_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_float4x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_float4x4"); + } + + // TYPEDEF: Glsl_int2 //check if this type has an existing base + type = atomicTypes.get("Glsl_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_int2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_int2"); + } + + // TYPEDEF: Glsl_int3 //check if this type has an existing base + type = atomicTypes.get("Glsl_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_int3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_int3"); + } + + // TYPEDEF: Glsl_int4 //check if this type has an existing base + type = atomicTypes.get("Glsl_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_int4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_int4"); + } + + // ENUM: Glsl_pipeline_stage + type = new daeEnumType(dae); + type->_nameBindings.append("Glsl_pipeline_stage"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("VERTEXPROGRAM"); + ((daeEnumType*)type)->_values->append(GLSL_PIPELINE_STAGE_VERTEXPROGRAM); + ((daeEnumType*)type)->_strings->append("FRAGMENTPROGRAM"); + ((daeEnumType*)type)->_values->append(GLSL_PIPELINE_STAGE_FRAGMENTPROGRAM); + atomicTypes.append( type ); + + // TYPEDEF: Glsl_identifier //check if this type has an existing base + type = atomicTypes.get("xsToken"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Glsl_identifier"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Glsl_identifier"); + } + + // TYPEDEF: Cg_bool //check if this type has an existing base + type = atomicTypes.get("xsBoolean"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool"); + } + + // TYPEDEF: Cg_float //check if this type has an existing base + type = atomicTypes.get("xsFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float"); + } + + // TYPEDEF: Cg_int //check if this type has an existing base + type = atomicTypes.get("xsInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int"); + } + + // TYPEDEF: Cg_half //check if this type has an existing base + type = atomicTypes.get("xsFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half"); + } + + // TYPEDEF: Cg_fixed //check if this type has an existing base + type = atomicTypes.get("xsFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed"); + } + + // TYPEDEF: Cg_bool1 //check if this type has an existing base + type = atomicTypes.get("xsBoolean"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool1"); + } + + // TYPEDEF: Cg_float1 //check if this type has an existing base + type = atomicTypes.get("xsFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float1"); + } + + // TYPEDEF: Cg_int1 //check if this type has an existing base + type = atomicTypes.get("xsInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int1"); + } + + // TYPEDEF: Cg_half1 //check if this type has an existing base + type = atomicTypes.get("xsFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half1"); + } + + // TYPEDEF: Cg_fixed1 //check if this type has an existing base + type = atomicTypes.get("xsFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed1"); + } + + // TYPEDEF: Cg_ListOfBool //check if this type has an existing base + type = atomicTypes.get("Cg_bool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_ListOfBool"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_ListOfBool"); + } + + // TYPEDEF: Cg_ListOfFloat //check if this type has an existing base + type = atomicTypes.get("Cg_float"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_ListOfFloat"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_ListOfFloat"); + } + + // TYPEDEF: Cg_ListOfInt //check if this type has an existing base + type = atomicTypes.get("Cg_int"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_ListOfInt"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_ListOfInt"); + } + + // TYPEDEF: Cg_ListOfHalf //check if this type has an existing base + type = atomicTypes.get("Cg_half"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_ListOfHalf"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_ListOfHalf"); + } + + // TYPEDEF: Cg_ListOfFixed //check if this type has an existing base + type = atomicTypes.get("Cg_fixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_ListOfFixed"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_ListOfFixed"); + } + + // TYPEDEF: Cg_bool2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool2"); + } + + // TYPEDEF: Cg_bool3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool3"); + } + + // TYPEDEF: Cg_bool4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool4"); + } + + // TYPEDEF: Cg_bool1x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool1x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool1x1"); + } + + // TYPEDEF: Cg_bool1x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool1x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool1x2"); + } + + // TYPEDEF: Cg_bool1x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool1x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool1x3"); + } + + // TYPEDEF: Cg_bool1x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool1x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool1x4"); + } + + // TYPEDEF: Cg_bool2x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool2x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool2x1"); + } + + // TYPEDEF: Cg_bool2x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool2x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool2x2"); + } + + // TYPEDEF: Cg_bool2x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool2x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool2x3"); + } + + // TYPEDEF: Cg_bool2x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool2x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool2x4"); + } + + // TYPEDEF: Cg_bool3x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool3x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool3x1"); + } + + // TYPEDEF: Cg_bool3x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool3x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool3x2"); + } + + // TYPEDEF: Cg_bool3x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool3x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool3x3"); + } + + // TYPEDEF: Cg_bool3x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool3x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool3x4"); + } + + // TYPEDEF: Cg_bool4x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool4x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool4x1"); + } + + // TYPEDEF: Cg_bool4x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool4x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool4x2"); + } + + // TYPEDEF: Cg_bool4x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool4x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool4x3"); + } + + // TYPEDEF: Cg_bool4x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfBool"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_bool4x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_bool4x4"); + } + + // TYPEDEF: Cg_float2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float2"); + } + + // TYPEDEF: Cg_float3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float3"); + } + + // TYPEDEF: Cg_float4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float4"); + } + + // TYPEDEF: Cg_float1x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float1x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float1x1"); + } + + // TYPEDEF: Cg_float1x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float1x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float1x2"); + } + + // TYPEDEF: Cg_float1x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float1x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float1x3"); + } + + // TYPEDEF: Cg_float1x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float1x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float1x4"); + } + + // TYPEDEF: Cg_float2x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float2x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float2x1"); + } + + // TYPEDEF: Cg_float2x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float2x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float2x2"); + } + + // TYPEDEF: Cg_float2x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float2x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float2x3"); + } + + // TYPEDEF: Cg_float2x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float2x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float2x4"); + } + + // TYPEDEF: Cg_float3x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float3x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float3x1"); + } + + // TYPEDEF: Cg_float3x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float3x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float3x2"); + } + + // TYPEDEF: Cg_float3x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float3x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float3x3"); + } + + // TYPEDEF: Cg_float3x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float3x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float3x4"); + } + + // TYPEDEF: Cg_float4x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float4x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float4x1"); + } + + // TYPEDEF: Cg_float4x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float4x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float4x2"); + } + + // TYPEDEF: Cg_float4x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float4x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float4x3"); + } + + // TYPEDEF: Cg_float4x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFloat"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_float4x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_float4x4"); + } + + // TYPEDEF: Cg_int2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int2"); + } + + // TYPEDEF: Cg_int3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int3"); + } + + // TYPEDEF: Cg_int4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int4"); + } + + // TYPEDEF: Cg_int1x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int1x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int1x1"); + } + + // TYPEDEF: Cg_int1x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int1x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int1x2"); + } + + // TYPEDEF: Cg_int1x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int1x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int1x3"); + } + + // TYPEDEF: Cg_int1x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int1x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int1x4"); + } + + // TYPEDEF: Cg_int2x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int2x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int2x1"); + } + + // TYPEDEF: Cg_int2x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int2x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int2x2"); + } + + // TYPEDEF: Cg_int2x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int2x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int2x3"); + } + + // TYPEDEF: Cg_int2x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int2x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int2x4"); + } + + // TYPEDEF: Cg_int3x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int3x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int3x1"); + } + + // TYPEDEF: Cg_int3x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int3x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int3x2"); + } + + // TYPEDEF: Cg_int3x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int3x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int3x3"); + } + + // TYPEDEF: Cg_int3x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int3x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int3x4"); + } + + // TYPEDEF: Cg_int4x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int4x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int4x1"); + } + + // TYPEDEF: Cg_int4x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int4x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int4x2"); + } + + // TYPEDEF: Cg_int4x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int4x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int4x3"); + } + + // TYPEDEF: Cg_int4x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfInt"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_int4x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_int4x4"); + } + + // TYPEDEF: Cg_half2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half2"); + } + + // TYPEDEF: Cg_half3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half3"); + } + + // TYPEDEF: Cg_half4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half4"); + } + + // TYPEDEF: Cg_half1x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half1x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half1x1"); + } + + // TYPEDEF: Cg_half1x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half1x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half1x2"); + } + + // TYPEDEF: Cg_half1x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half1x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half1x3"); + } + + // TYPEDEF: Cg_half1x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half1x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half1x4"); + } + + // TYPEDEF: Cg_half2x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half2x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half2x1"); + } + + // TYPEDEF: Cg_half2x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half2x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half2x2"); + } + + // TYPEDEF: Cg_half2x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half2x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half2x3"); + } + + // TYPEDEF: Cg_half2x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half2x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half2x4"); + } + + // TYPEDEF: Cg_half3x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half3x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half3x1"); + } + + // TYPEDEF: Cg_half3x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half3x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half3x2"); + } + + // TYPEDEF: Cg_half3x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half3x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half3x3"); + } + + // TYPEDEF: Cg_half3x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half3x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half3x4"); + } + + // TYPEDEF: Cg_half4x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half4x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half4x1"); + } + + // TYPEDEF: Cg_half4x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half4x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half4x2"); + } + + // TYPEDEF: Cg_half4x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half4x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half4x3"); + } + + // TYPEDEF: Cg_half4x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfHalf"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_half4x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_half4x4"); + } + + // TYPEDEF: Cg_fixed2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed2"); + } + + // TYPEDEF: Cg_fixed3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed3"); + } + + // TYPEDEF: Cg_fixed4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed4"); + } + + // TYPEDEF: Cg_fixed1x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed1x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed1x1"); + } + + // TYPEDEF: Cg_fixed1x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed1x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed1x2"); + } + + // TYPEDEF: Cg_fixed1x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed1x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed1x3"); + } + + // TYPEDEF: Cg_fixed1x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed1x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed1x4"); + } + + // TYPEDEF: Cg_fixed2x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed2x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed2x1"); + } + + // TYPEDEF: Cg_fixed2x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed2x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed2x2"); + } + + // TYPEDEF: Cg_fixed2x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed2x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed2x3"); + } + + // TYPEDEF: Cg_fixed2x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed2x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed2x4"); + } + + // TYPEDEF: Cg_fixed3x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed3x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed3x1"); + } + + // TYPEDEF: Cg_fixed3x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed3x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed3x2"); + } + + // TYPEDEF: Cg_fixed3x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed3x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed3x3"); + } + + // TYPEDEF: Cg_fixed3x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed3x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed3x4"); + } + + // TYPEDEF: Cg_fixed4x1 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed4x1"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed4x1"); + } + + // TYPEDEF: Cg_fixed4x2 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed4x2"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed4x2"); + } + + // TYPEDEF: Cg_fixed4x3 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed4x3"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed4x3"); + } + + // TYPEDEF: Cg_fixed4x4 //check if this type has an existing base + type = atomicTypes.get("Cg_ListOfFixed"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_fixed4x4"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_fixed4x4"); + } + + // ENUM: Cg_pipeline_stage + type = new daeEnumType(dae); + type->_nameBindings.append("Cg_pipeline_stage"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("VERTEX"); + ((daeEnumType*)type)->_values->append(CG_PIPELINE_STAGE_VERTEX); + ((daeEnumType*)type)->_strings->append("FRAGMENT"); + ((daeEnumType*)type)->_values->append(CG_PIPELINE_STAGE_FRAGMENT); + atomicTypes.append( type ); + + // TYPEDEF: Cg_identifier //check if this type has an existing base + type = atomicTypes.get("xsToken"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Cg_identifier"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Cg_identifier"); + } + + // TYPEDEF: GLES_MAX_LIGHTS_index //check if this type has an existing base + type = atomicTypes.get("xsNonNegativeInteger"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("GLES_MAX_LIGHTS_index"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("GLES_MAX_LIGHTS_index"); + } + + // TYPEDEF: GLES_MAX_CLIP_PLANES_index //check if this type has an existing base + type = atomicTypes.get("xsNonNegativeInteger"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("GLES_MAX_CLIP_PLANES_index"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("GLES_MAX_CLIP_PLANES_index"); + } + + // TYPEDEF: GLES_MAX_TEXTURE_COORDS_index //check if this type has an existing base + type = atomicTypes.get("xsNonNegativeInteger"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("GLES_MAX_TEXTURE_COORDS_index"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("GLES_MAX_TEXTURE_COORDS_index"); + } + + // TYPEDEF: GLES_MAX_TEXTURE_IMAGE_UNITS_index //check if this type has an existing base + type = atomicTypes.get("xsNonNegativeInteger"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("GLES_MAX_TEXTURE_IMAGE_UNITS_index"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("GLES_MAX_TEXTURE_IMAGE_UNITS_index"); + } + + // ENUM: Gles_texenv_mode_enums + type = new daeEnumType(dae); + type->_nameBindings.append("Gles_texenv_mode_enums"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("REPLACE"); + ((daeEnumType*)type)->_values->append(GLES_TEXENV_MODE_ENUMS_REPLACE); + ((daeEnumType*)type)->_strings->append("MODULATE"); + ((daeEnumType*)type)->_values->append(GLES_TEXENV_MODE_ENUMS_MODULATE); + ((daeEnumType*)type)->_strings->append("DECAL"); + ((daeEnumType*)type)->_values->append(GLES_TEXENV_MODE_ENUMS_DECAL); + ((daeEnumType*)type)->_strings->append("BLEND"); + ((daeEnumType*)type)->_values->append(GLES_TEXENV_MODE_ENUMS_BLEND); + ((daeEnumType*)type)->_strings->append("ADD"); + ((daeEnumType*)type)->_values->append(GLES_TEXENV_MODE_ENUMS_ADD); + atomicTypes.append( type ); + + // ENUM: Gles_texcombiner_operatorRGB_enums + type = new daeEnumType(dae); + type->_nameBindings.append("Gles_texcombiner_operatorRGB_enums"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("REPLACE"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERATORRGB_ENUMS_REPLACE); + ((daeEnumType*)type)->_strings->append("MODULATE"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERATORRGB_ENUMS_MODULATE); + ((daeEnumType*)type)->_strings->append("ADD"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERATORRGB_ENUMS_ADD); + ((daeEnumType*)type)->_strings->append("ADD_SIGNED"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERATORRGB_ENUMS_ADD_SIGNED); + ((daeEnumType*)type)->_strings->append("INTERPOLATE"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERATORRGB_ENUMS_INTERPOLATE); + ((daeEnumType*)type)->_strings->append("SUBTRACT"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERATORRGB_ENUMS_SUBTRACT); + ((daeEnumType*)type)->_strings->append("DOT3_RGB"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERATORRGB_ENUMS_DOT3_RGB); + ((daeEnumType*)type)->_strings->append("DOT3_RGBA"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERATORRGB_ENUMS_DOT3_RGBA); + atomicTypes.append( type ); + + // ENUM: Gles_texcombiner_operatorAlpha_enums + type = new daeEnumType(dae); + type->_nameBindings.append("Gles_texcombiner_operatorAlpha_enums"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("REPLACE"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERATORALPHA_ENUMS_REPLACE); + ((daeEnumType*)type)->_strings->append("MODULATE"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERATORALPHA_ENUMS_MODULATE); + ((daeEnumType*)type)->_strings->append("ADD"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERATORALPHA_ENUMS_ADD); + ((daeEnumType*)type)->_strings->append("ADD_SIGNED"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERATORALPHA_ENUMS_ADD_SIGNED); + ((daeEnumType*)type)->_strings->append("INTERPOLATE"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERATORALPHA_ENUMS_INTERPOLATE); + ((daeEnumType*)type)->_strings->append("SUBTRACT"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERATORALPHA_ENUMS_SUBTRACT); + atomicTypes.append( type ); + + // ENUM: Gles_texcombiner_source_enums + type = new daeEnumType(dae); + type->_nameBindings.append("Gles_texcombiner_source_enums"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("TEXTURE"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_SOURCE_ENUMS_TEXTURE); + ((daeEnumType*)type)->_strings->append("CONSTANT"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_SOURCE_ENUMS_CONSTANT); + ((daeEnumType*)type)->_strings->append("PRIMARY"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_SOURCE_ENUMS_PRIMARY); + ((daeEnumType*)type)->_strings->append("PREVIOUS"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_SOURCE_ENUMS_PREVIOUS); + atomicTypes.append( type ); + + // ENUM: Gles_texcombiner_operandRGB_enums + type = new daeEnumType(dae); + type->_nameBindings.append("Gles_texcombiner_operandRGB_enums"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("SRC_COLOR"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERANDRGB_ENUMS_SRC_COLOR); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_SRC_COLOR"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERANDRGB_ENUMS_ONE_MINUS_SRC_COLOR); + ((daeEnumType*)type)->_strings->append("SRC_ALPHA"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERANDRGB_ENUMS_SRC_ALPHA); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_SRC_ALPHA"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERANDRGB_ENUMS_ONE_MINUS_SRC_ALPHA); + atomicTypes.append( type ); + + // ENUM: Gles_texcombiner_operandAlpha_enums + type = new daeEnumType(dae); + type->_nameBindings.append("Gles_texcombiner_operandAlpha_enums"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("SRC_ALPHA"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERANDALPHA_ENUMS_SRC_ALPHA); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_SRC_ALPHA"); + ((daeEnumType*)type)->_values->append(GLES_TEXCOMBINER_OPERANDALPHA_ENUMS_ONE_MINUS_SRC_ALPHA); + atomicTypes.append( type ); + + // TYPEDEF: Gles_texcombiner_argument_index_type //check if this type has an existing base + type = atomicTypes.get("xsNonNegativeInteger"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Gles_texcombiner_argument_index_type"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Gles_texcombiner_argument_index_type"); + } + + // ENUM: Gles_sampler_wrap + type = new daeEnumType(dae); + type->_nameBindings.append("Gles_sampler_wrap"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("REPEAT"); + ((daeEnumType*)type)->_values->append(GLES_SAMPLER_WRAP_REPEAT); + ((daeEnumType*)type)->_strings->append("CLAMP"); + ((daeEnumType*)type)->_values->append(GLES_SAMPLER_WRAP_CLAMP); + ((daeEnumType*)type)->_strings->append("CLAMP_TO_EDGE"); + ((daeEnumType*)type)->_values->append(GLES_SAMPLER_WRAP_CLAMP_TO_EDGE); + ((daeEnumType*)type)->_strings->append("MIRRORED_REPEAT"); + ((daeEnumType*)type)->_values->append(GLES_SAMPLER_WRAP_MIRRORED_REPEAT); + atomicTypes.append( type ); + + // ENUM: Gles_stencil_op_type + type = new daeEnumType(dae); + type->_nameBindings.append("Gles_stencil_op_type"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("KEEP"); + ((daeEnumType*)type)->_values->append(GLES_STENCIL_OP_TYPE_KEEP); + ((daeEnumType*)type)->_strings->append("ZERO"); + ((daeEnumType*)type)->_values->append(GLES_STENCIL_OP_TYPE_ZERO); + ((daeEnumType*)type)->_strings->append("REPLACE"); + ((daeEnumType*)type)->_values->append(GLES_STENCIL_OP_TYPE_REPLACE); + ((daeEnumType*)type)->_strings->append("INCR"); + ((daeEnumType*)type)->_values->append(GLES_STENCIL_OP_TYPE_INCR); + ((daeEnumType*)type)->_strings->append("DECR"); + ((daeEnumType*)type)->_values->append(GLES_STENCIL_OP_TYPE_DECR); + ((daeEnumType*)type)->_strings->append("INVERT"); + ((daeEnumType*)type)->_values->append(GLES_STENCIL_OP_TYPE_INVERT); + atomicTypes.append( type ); + + // ENUM: Gles_enumeration + type = new daeEnumType(dae); + type->_nameBindings.append("Gles_enumeration"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("ZERO"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_ZERO); + ((daeEnumType*)type)->_strings->append("ONE"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_ONE); + ((daeEnumType*)type)->_strings->append("SRC_COLOR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_SRC_COLOR); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_SRC_COLOR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_ONE_MINUS_SRC_COLOR); + ((daeEnumType*)type)->_strings->append("DEST_COLOR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_DEST_COLOR); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_DEST_COLOR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_ONE_MINUS_DEST_COLOR); + ((daeEnumType*)type)->_strings->append("SRC_ALPHA"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_SRC_ALPHA); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_SRC_ALPHA"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_ONE_MINUS_SRC_ALPHA); + ((daeEnumType*)type)->_strings->append("DST_ALPHA"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_DST_ALPHA); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_DST_ALPHA"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_ONE_MINUS_DST_ALPHA); + ((daeEnumType*)type)->_strings->append("CONSTANT_COLOR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_CONSTANT_COLOR); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_CONSTANT_COLOR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_ONE_MINUS_CONSTANT_COLOR); + ((daeEnumType*)type)->_strings->append("CONSTANT_ALPHA"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_CONSTANT_ALPHA); + ((daeEnumType*)type)->_strings->append("ONE_MINUS_CONSTANT_ALPHA"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_ONE_MINUS_CONSTANT_ALPHA); + ((daeEnumType*)type)->_strings->append("SRC_ALPHA_SATURATE"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_SRC_ALPHA_SATURATE); + ((daeEnumType*)type)->_strings->append("FRONT"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_FRONT); + ((daeEnumType*)type)->_strings->append("BACK"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_BACK); + ((daeEnumType*)type)->_strings->append("FRONT_AND_BACK"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_FRONT_AND_BACK); + ((daeEnumType*)type)->_strings->append("NEVER"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_NEVER); + ((daeEnumType*)type)->_strings->append("LESS"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_LESS); + ((daeEnumType*)type)->_strings->append("LEQUAL"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_LEQUAL); + ((daeEnumType*)type)->_strings->append("EQUAL"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_EQUAL); + ((daeEnumType*)type)->_strings->append("GREATER"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_GREATER); + ((daeEnumType*)type)->_strings->append("NOTEQUAL"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_NOTEQUAL); + ((daeEnumType*)type)->_strings->append("GEQUAL"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_GEQUAL); + ((daeEnumType*)type)->_strings->append("ALWAYS"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_ALWAYS); + ((daeEnumType*)type)->_strings->append("KEEP"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_KEEP); + ((daeEnumType*)type)->_strings->append("REPLACE"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_REPLACE); + ((daeEnumType*)type)->_strings->append("INCR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_INCR); + ((daeEnumType*)type)->_strings->append("DECR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_DECR); + ((daeEnumType*)type)->_strings->append("INVERT"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_INVERT); + ((daeEnumType*)type)->_strings->append("INCR_WRAP"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_INCR_WRAP); + ((daeEnumType*)type)->_strings->append("DECR_WRAP"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_DECR_WRAP); + ((daeEnumType*)type)->_strings->append("EMISSION"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_EMISSION); + ((daeEnumType*)type)->_strings->append("AMBIENT"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_AMBIENT); + ((daeEnumType*)type)->_strings->append("DIFFUSE"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_DIFFUSE); + ((daeEnumType*)type)->_strings->append("SPECULAR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_SPECULAR); + ((daeEnumType*)type)->_strings->append("AMBIENT_AND_DIFFUSE"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_AMBIENT_AND_DIFFUSE); + ((daeEnumType*)type)->_strings->append("LINEAR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_LINEAR); + ((daeEnumType*)type)->_strings->append("EXP"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_EXP); + ((daeEnumType*)type)->_strings->append("EXP2"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_EXP2); + ((daeEnumType*)type)->_strings->append("CW"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_CW); + ((daeEnumType*)type)->_strings->append("CCW"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_CCW); + ((daeEnumType*)type)->_strings->append("SINGLE_COLOR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_SINGLE_COLOR); + ((daeEnumType*)type)->_strings->append("SEPARATE_SPECULAR_COLOR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_SEPARATE_SPECULAR_COLOR); + ((daeEnumType*)type)->_strings->append("CLEAR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_CLEAR); + ((daeEnumType*)type)->_strings->append("AND"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_AND); + ((daeEnumType*)type)->_strings->append("AND_REVERSE"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_AND_REVERSE); + ((daeEnumType*)type)->_strings->append("COPY"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_COPY); + ((daeEnumType*)type)->_strings->append("AND_INVERTED"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_AND_INVERTED); + ((daeEnumType*)type)->_strings->append("NOOP"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_NOOP); + ((daeEnumType*)type)->_strings->append("XOR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_XOR); + ((daeEnumType*)type)->_strings->append("OR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_OR); + ((daeEnumType*)type)->_strings->append("NOR"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_NOR); + ((daeEnumType*)type)->_strings->append("EQUIV"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_EQUIV); + ((daeEnumType*)type)->_strings->append("OR_REVERSE"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_OR_REVERSE); + ((daeEnumType*)type)->_strings->append("COPY_INVERTED"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_COPY_INVERTED); + ((daeEnumType*)type)->_strings->append("NAND"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_NAND); + ((daeEnumType*)type)->_strings->append("SET"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_SET); + ((daeEnumType*)type)->_strings->append("POINT"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_POINT); + ((daeEnumType*)type)->_strings->append("LINE"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_LINE); + ((daeEnumType*)type)->_strings->append("FILL"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_FILL); + ((daeEnumType*)type)->_strings->append("FLAT"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_FLAT); + ((daeEnumType*)type)->_strings->append("SMOOTH"); + ((daeEnumType*)type)->_values->append(GLES_ENUMERATION_SMOOTH); + atomicTypes.append( type ); + + // TYPEDEF: Gles_rendertarget_common //check if this type has an existing base + type = atomicTypes.get("xsNCName"); + if ( type == NULL ) { //register as a raw type + type = new daeRawRefType(dae); + type->_nameBindings.append("Gles_rendertarget_common"); + atomicTypes.append( type ); + } + else { //add binding to existing type + type->_nameBindings.append("Gles_rendertarget_common"); + } + + // ENUM: SpringType + type = new daeEnumType(dae); + type->_nameBindings.append("SpringType"); + ((daeEnumType*)type)->_strings = new daeStringRefArray; + ((daeEnumType*)type)->_values = new daeEnumArray; + ((daeEnumType*)type)->_strings->append("LINEAR"); + ((daeEnumType*)type)->_values->append(SPRINGTYPE_LINEAR); + ((daeEnumType*)type)->_strings->append("ANGULAR"); + ((daeEnumType*)type)->_values->append(SPRINGTYPE_ANGULAR); + atomicTypes.append( type ); + +} + +daeMetaElement* registerDomElements(DAE& dae) +{ + daeMetaElement* meta = domCOLLADA::registerElement(dae); + // Enable tracking of top level object by default + meta->setIsTrackableForQueries(true); + return meta; +} + +daeInt colladaTypeCount() { + return 815; +} + +} diff --git a/1.4.0/dom/src/1.4/dom/domVertices.cpp b/1.4.0/dom/src/1.4/dom/domVertices.cpp new file mode 100644 index 0000000..b14ba87 --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domVertices.cpp @@ -0,0 +1,88 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domVertices.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domVertices::create(DAE& dae) +{ + domVerticesRef ref = new domVertices(dae); + return ref; +} + + +daeMetaElement * +domVertices::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "vertices" ); + meta->registerClass(domVertices::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, -1 ); + mea->setName( "input" ); + mea->setOffset( daeOffsetOf(domVertices,elemInput_array) ); + mea->setElementType( domInputLocal::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domVertices,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domVertices , attrId )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domVertices , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domVertices)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 diff --git a/1.4.0/dom/src/1.4/dom/domVisual_scene.cpp b/1.4.0/dom/src/1.4/dom/domVisual_scene.cpp new file mode 100644 index 0000000..eb3caac --- /dev/null +++ b/1.4.0/dom/src/1.4/dom/domVisual_scene.cpp @@ -0,0 +1,243 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ + +#include <dae.h> +#include <dae/daeDom.h> +#include <1.4/dom/domVisual_scene.h> +#include <dae/daeMetaCMPolicy.h> +#include <dae/daeMetaSequence.h> +#include <dae/daeMetaChoice.h> +#include <dae/daeMetaGroup.h> +#include <dae/daeMetaAny.h> +#include <dae/daeMetaElementAttribute.h> + + +namespace ColladaDOM141 { +daeElementRef +domVisual_scene::create(DAE& dae) +{ + domVisual_sceneRef ref = new domVisual_scene(dae); + return ref; +} + + +daeMetaElement * +domVisual_scene::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "visual_scene" ); + meta->registerClass(domVisual_scene::create); + + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementAttribute( meta, cm, 0, 0, 1 ); + mea->setName( "asset" ); + mea->setOffset( daeOffsetOf(domVisual_scene,elemAsset) ); + mea->setElementType( domAsset::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 1, 1, -1 ); + mea->setName( "node" ); + mea->setOffset( daeOffsetOf(domVisual_scene,elemNode_array) ); + mea->setElementType( domNode::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 2, 0, -1 ); + mea->setName( "evaluate_scene" ); + mea->setOffset( daeOffsetOf(domVisual_scene,elemEvaluate_scene_array) ); + mea->setElementType( domVisual_scene::domEvaluate_scene::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 3, 0, -1 ); + mea->setName( "extra" ); + mea->setOffset( daeOffsetOf(domVisual_scene,elemExtra_array) ); + mea->setElementType( domExtra::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 3 ); + meta->setCMRoot( cm ); + + // Add attribute: id + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "id" ); + ma->setType( dae.getAtomicTypes().get("xsID")); + ma->setOffset( daeOffsetOf( domVisual_scene , attrId )); + ma->setContainer( meta ); + ma->setIsRequired( false ); + + meta->appendAttribute(ma); + } + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domVisual_scene , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domVisual_scene)); + meta->validate(); + + return meta; +} + +daeElementRef +domVisual_scene::domEvaluate_scene::create(DAE& dae) +{ + domVisual_scene::domEvaluate_sceneRef ref = new domVisual_scene::domEvaluate_scene(dae); + return ref; +} + + +daeMetaElement * +domVisual_scene::domEvaluate_scene::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "evaluate_scene" ); + meta->registerClass(domVisual_scene::domEvaluate_scene::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 1, -1 ); + mea->setName( "render" ); + mea->setOffset( daeOffsetOf(domVisual_scene::domEvaluate_scene,elemRender_array) ); + mea->setElementType( domVisual_scene::domEvaluate_scene::domRender::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 0 ); + meta->setCMRoot( cm ); + + // Add attribute: name + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "name" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domVisual_scene::domEvaluate_scene , attrName )); + ma->setContainer( meta ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domVisual_scene::domEvaluate_scene)); + meta->validate(); + + return meta; +} + +daeElementRef +domVisual_scene::domEvaluate_scene::domRender::create(DAE& dae) +{ + domVisual_scene::domEvaluate_scene::domRenderRef ref = new domVisual_scene::domEvaluate_scene::domRender(dae); + return ref; +} + + +daeMetaElement * +domVisual_scene::domEvaluate_scene::domRender::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "render" ); + meta->registerClass(domVisual_scene::domEvaluate_scene::domRender::create); + + meta->setIsInnerClass( true ); + daeMetaCMPolicy *cm = NULL; + daeMetaElementAttribute *mea = NULL; + cm = new daeMetaSequence( meta, cm, 0, 1, 1 ); + + mea = new daeMetaElementArrayAttribute( meta, cm, 0, 0, -1 ); + mea->setName( "layer" ); + mea->setOffset( daeOffsetOf(domVisual_scene::domEvaluate_scene::domRender,elemLayer_array) ); + mea->setElementType( domVisual_scene::domEvaluate_scene::domRender::domLayer::registerElement(dae) ); + cm->appendChild( mea ); + + mea = new daeMetaElementAttribute( meta, cm, 1, 0, 1 ); + mea->setName( "instance_effect" ); + mea->setOffset( daeOffsetOf(domVisual_scene::domEvaluate_scene::domRender,elemInstance_effect) ); + mea->setElementType( domInstance_effect::registerElement(dae) ); + cm->appendChild( mea ); + + cm->setMaxOrdinal( 1 ); + meta->setCMRoot( cm ); + + // Add attribute: camera_node + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "camera_node" ); + ma->setType( dae.getAtomicTypes().get("xsAnyURI")); + ma->setOffset( daeOffsetOf( domVisual_scene::domEvaluate_scene::domRender , attrCamera_node )); + ma->setContainer( meta ); + ma->setIsRequired( true ); + + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domVisual_scene::domEvaluate_scene::domRender)); + meta->validate(); + + return meta; +} + +daeElementRef +domVisual_scene::domEvaluate_scene::domRender::domLayer::create(DAE& dae) +{ + domVisual_scene::domEvaluate_scene::domRender::domLayerRef ref = new domVisual_scene::domEvaluate_scene::domRender::domLayer(dae); + return ref; +} + + +daeMetaElement * +domVisual_scene::domEvaluate_scene::domRender::domLayer::registerElement(DAE& dae) +{ + daeMetaElement* meta = dae.getMeta(ID()); + if ( meta != NULL ) return meta; + + meta = new daeMetaElement(dae); + dae.setMeta(ID(), *meta); + meta->setName( "layer" ); + meta->registerClass(domVisual_scene::domEvaluate_scene::domRender::domLayer::create); + + meta->setIsInnerClass( true ); + // Add attribute: _value + { + daeMetaAttribute *ma = new daeMetaAttribute; + ma->setName( "_value" ); + ma->setType( dae.getAtomicTypes().get("xsNCName")); + ma->setOffset( daeOffsetOf( domVisual_scene::domEvaluate_scene::domRender::domLayer , _value )); + ma->setContainer( meta ); + meta->appendAttribute(ma); + } + + meta->setElementSize(sizeof(domVisual_scene::domEvaluate_scene::domRender::domLayer)); + meta->validate(); + + return meta; +} + +} // ColladaDOM141 |