Engine directory for ticket #1

Engine/lib/collada/src/1.4/dom/domAccessor.cpp

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domAnimation.cpp

@@ -0,0 +1,177 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domAnimation_clip.cpp

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domAsset.cpp

@@ -0,0 +1,655 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domBind_material.cpp

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domBool_array.cpp

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domBox.cpp

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCOLLADA.cpp

@@ -0,0 +1,264 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCamera.cpp

@@ -0,0 +1,452 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCapsule.cpp

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCg_connect_param.cpp

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCg_newarray_type.cpp

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCg_newparam.cpp

@@ -0,0 +1,185 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCg_sampler1D.cpp

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCg_sampler2D.cpp

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCg_sampler3D.cpp

@@ -0,0 +1,127 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCg_samplerCUBE.cpp

@@ -0,0 +1,127 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCg_samplerDEPTH.cpp

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCg_samplerRECT.cpp

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCg_setarray_type.cpp

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCg_setparam.cpp

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCg_setparam_simple.cpp

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCg_setuser_type.cpp

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCg_surface_type.cpp

@@ -0,0 +1,264 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domChannel.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCommon_color_or_texture_type.cpp

@@ -0,0 +1,226 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCommon_float_or_param_type.cpp

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCommon_newparam_type.cpp

@@ -0,0 +1,299 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCommon_transparent_type.cpp

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domController.cpp

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domConvex_mesh.cpp

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domCylinder.cpp

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domEffect.cpp

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+daeElementRef
+domEffect::create(DAE& dae)
+{
+	domEffectRef ref = new domEffect(dae);
+	return ref;
+}
+
+#include <dom/domProfile_GLSL.h>
+#include <dom/domProfile_COMMON.h>
+#include <dom/domProfile_CG.h>
+#include <dom/domProfile_GLES.h>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domEllipsoid.cpp

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domExtra.cpp

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFloat_array.cpp

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domForce_field.cpp

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_annotate_common.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_annotate_type_common.cpp

@@ -0,0 +1,732 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_clearcolor_common.cpp

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_cleardepth_common.cpp

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_clearstencil_common.cpp

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_code_profile.cpp

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_colortarget_common.cpp

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_depthtarget_common.cpp

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_include_common.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_newparam_common.cpp

@@ -0,0 +1,163 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_profile_abstract.cpp

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_sampler1D_common.cpp

@@ -0,0 +1,397 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_sampler2D_common.cpp

@@ -0,0 +1,439 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_sampler3D_common.cpp

@@ -0,0 +1,481 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_samplerCUBE_common.cpp

@@ -0,0 +1,481 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_samplerDEPTH_common.cpp

@@ -0,0 +1,271 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_samplerRECT_common.cpp

@@ -0,0 +1,439 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_stenciltarget_common.cpp

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_surface_common.cpp

@@ -0,0 +1,305 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_surface_format_hint_common.cpp

@@ -0,0 +1,229 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_surface_init_common.cpp

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_surface_init_cube_common.cpp

@@ -0,0 +1,242 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_surface_init_from_common.cpp

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_surface_init_planar_common.cpp

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domFx_surface_init_volume_common.cpp

@@ -0,0 +1,149 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGeometry.cpp

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGl_hook_abstract.cpp

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGl_sampler1D.cpp

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGl_sampler2D.cpp

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGl_sampler3D.cpp

@@ -0,0 +1,127 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGl_samplerCUBE.cpp

@@ -0,0 +1,127 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGl_samplerDEPTH.cpp

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGl_samplerRECT.cpp

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGles_newparam.cpp

@@ -0,0 +1,163 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGles_sampler_state.cpp

@@ -0,0 +1,366 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGles_texcombiner_argumentAlpha_type.cpp

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGles_texcombiner_argumentRGB_type.cpp

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGles_texcombiner_commandAlpha_type.cpp

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGles_texcombiner_commandRGB_type.cpp

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGles_texcombiner_command_type.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGles_texenv_command_type.cpp

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGles_texture_constant_type.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGles_texture_pipeline.cpp

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGles_texture_unit.cpp

@@ -0,0 +1,200 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGlsl_newarray_type.cpp

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGlsl_newparam.cpp

@@ -0,0 +1,179 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGlsl_param_type.cpp

@@ -0,0 +1,774 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGlsl_setarray_type.cpp

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGlsl_setparam.cpp

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGlsl_setparam_simple.cpp

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domGlsl_surface_type.cpp

@@ -0,0 +1,264 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domIDREF_array.cpp

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domImage.cpp

@@ -0,0 +1,228 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domInputGlobal.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domInputLocal.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domInputLocalOffset.cpp

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+

Engine/lib/collada/src/1.4/dom/domInstanceWithExtra.cpp

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2006 Sony Computer Entertainment Inc.
+ *
+ * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://research.scea.com/scea_shared_source_license.html
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing permissions and limitations under the
+ * License.
+ */
+
+#include <dae.h>
+#include <dae/daeDom.h>
+#include <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>
+
+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;
+}
+