added limited support for COLLADA_DOM. Will need to add jam/msvcgen build support.

Extras/COLLADA_DOM/src/1.4/dom/domAccessor.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/daeDom.h>
+#include <dom/domAccessor.h>
+
+daeElementRef
+domAccessor::create(daeInt bytes)
+{
+	domAccessorRef ref = new(bytes) domAccessor;
+	ref->attrSource.setContainer( (domAccessor*)ref );
+	return ref;
+}
+
+
+daeMetaElement *
+domAccessor::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "accessor" );
+	_Meta->setStaticPointerAddress(&domAccessor::_Meta);
+	_Meta->registerConstructor(domAccessor::create);
+
+	// Add elements: param
+    _Meta->appendArrayElement(domParam::registerElement(),daeOffsetOf(domAccessor,elemParam_array));
+
+	//	Add attribute: count
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "count" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("Uint"));
+		ma->setOffset( daeOffsetOf( domAccessor , attrOffset ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "0");
+	
+		_Meta->appendAttribute(ma);
+	}
+
+	//	Add attribute: source
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "source" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("Uint"));
+		ma->setOffset( daeOffsetOf( domAccessor , attrStride ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "1");
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domAccessor));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domAccessor::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domAnimation.cpp

@@ -0,0 +1,78 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domAnimation.h>
+
+daeElementRef
+domAnimation::create(daeInt bytes)
+{
+	domAnimationRef ref = new(bytes) domAnimation;
+	return ref;
+}
+
+
+daeMetaElement *
+domAnimation::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "animation" );
+	_Meta->setStaticPointerAddress(&domAnimation::_Meta);
+	_Meta->registerConstructor(domAnimation::create);
+
+	// Add elements: asset, source, sampler, channel, animation, extra
+    _Meta->appendElement(domAsset::registerElement(),daeOffsetOf(domAnimation,elemAsset));
+    _Meta->appendArrayElement(domSource::registerElement(),daeOffsetOf(domAnimation,elemSource_array));
+    _Meta->appendArrayElement(domSampler::registerElement(),daeOffsetOf(domAnimation,elemSampler_array));
+    _Meta->appendArrayElement(domChannel::registerElement(),daeOffsetOf(domAnimation,elemChannel_array));
+    _Meta->appendArrayElement(domAnimation::registerElement(),daeOffsetOf(domAnimation,elemAnimation_array));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domAnimation,elemExtra_array));
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domAnimation,_contents));
+
+
+	//	Add attribute: id
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "id" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("xsNCName"));
+		ma->setOffset( daeOffsetOf( domAnimation , attrName ));
+		ma->setContainer( _Meta );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domAnimation));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domAnimation::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domAnimation_clip.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/daeDom.h>
+#include <dom/domAnimation_clip.h>
+
+daeElementRef
+domAnimation_clip::create(daeInt bytes)
+{
+	domAnimation_clipRef ref = new(bytes) domAnimation_clip;
+	return ref;
+}
+
+
+daeMetaElement *
+domAnimation_clip::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "animation_clip" );
+	_Meta->setStaticPointerAddress(&domAnimation_clip::_Meta);
+	_Meta->registerConstructor(domAnimation_clip::create);
+
+	// Add elements: asset, instance_animation, extra
+    _Meta->appendElement(domAsset::registerElement(),daeOffsetOf(domAnimation_clip,elemAsset));
+    _Meta->appendArrayElement(domInstanceWithExtra::registerElement(),daeOffsetOf(domAnimation_clip,elemInstance_animation_array),"instance_animation"); 
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domAnimation_clip,elemExtra_array));
+
+	//	Add attribute: id
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "id" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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( daeAtomicType::get("xsDouble"));
+		ma->setOffset( daeOffsetOf( domAnimation_clip , attrStart ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "0.0");
+	
+		_Meta->appendAttribute(ma);
+	}
+
+	//	Add attribute: end
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "end" );
+		ma->setType( daeAtomicType::get("xsDouble"));
+		ma->setOffset( daeOffsetOf( domAnimation_clip , attrEnd ));
+		ma->setContainer( _Meta );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domAnimation_clip));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domAnimation_clip::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domAsset.cpp

@@ -0,0 +1,573 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domAsset.h>
+
+daeElementRef
+domAsset::create(daeInt bytes)
+{
+	domAssetRef ref = new(bytes) domAsset;
+	return ref;
+}
+
+
+daeMetaElement *
+domAsset::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "asset" );
+	_Meta->setStaticPointerAddress(&domAsset::_Meta);
+	_Meta->registerConstructor(domAsset::create);
+
+	// Add elements: contributor, created, keywords, modified, revision, subject, title, unit, up_axis
+    _Meta->appendArrayElement(domAsset::domContributor::registerElement(),daeOffsetOf(domAsset,elemContributor_array));
+    _Meta->appendElement(domAsset::domCreated::registerElement(),daeOffsetOf(domAsset,elemCreated));
+    _Meta->appendElement(domAsset::domKeywords::registerElement(),daeOffsetOf(domAsset,elemKeywords));
+    _Meta->appendElement(domAsset::domModified::registerElement(),daeOffsetOf(domAsset,elemModified));
+    _Meta->appendElement(domAsset::domRevision::registerElement(),daeOffsetOf(domAsset,elemRevision));
+    _Meta->appendElement(domAsset::domSubject::registerElement(),daeOffsetOf(domAsset,elemSubject));
+    _Meta->appendElement(domAsset::domTitle::registerElement(),daeOffsetOf(domAsset,elemTitle));
+    _Meta->appendElement(domAsset::domUnit::registerElement(),daeOffsetOf(domAsset,elemUnit));
+    _Meta->appendElement(domAsset::domUp_axis::registerElement(),daeOffsetOf(domAsset,elemUp_axis));
+	
+	
+	_Meta->setElementSize(sizeof(domAsset));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domAsset::domContributor::create(daeInt bytes)
+{
+	domAsset::domContributorRef ref = new(bytes) domAsset::domContributor;
+	return ref;
+}
+
+
+daeMetaElement *
+domAsset::domContributor::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "contributor" );
+	_Meta->setStaticPointerAddress(&domAsset::domContributor::_Meta);
+	_Meta->registerConstructor(domAsset::domContributor::create);
+
+	// Add elements: author, authoring_tool, comments, copyright, source_data
+    _Meta->appendElement(domAsset::domContributor::domAuthor::registerElement(),daeOffsetOf(domAsset::domContributor,elemAuthor));
+    _Meta->appendElement(domAsset::domContributor::domAuthoring_tool::registerElement(),daeOffsetOf(domAsset::domContributor,elemAuthoring_tool));
+    _Meta->appendElement(domAsset::domContributor::domComments::registerElement(),daeOffsetOf(domAsset::domContributor,elemComments));
+    _Meta->appendElement(domAsset::domContributor::domCopyright::registerElement(),daeOffsetOf(domAsset::domContributor,elemCopyright));
+    _Meta->appendElement(domAsset::domContributor::domSource_data::registerElement(),daeOffsetOf(domAsset::domContributor,elemSource_data));
+	
+	
+	_Meta->setElementSize(sizeof(domAsset::domContributor));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domAsset::domContributor::domAuthor::create(daeInt bytes)
+{
+	domAsset::domContributor::domAuthorRef ref = new(bytes) domAsset::domContributor::domAuthor;
+	return ref;
+}
+
+
+daeMetaElement *
+domAsset::domContributor::domAuthor::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "author" );
+	_Meta->setStaticPointerAddress(&domAsset::domContributor::domAuthor::_Meta);
+	_Meta->registerConstructor(domAsset::domContributor::domAuthor::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domAsset::domContributor::domAuthoring_toolRef ref = new(bytes) domAsset::domContributor::domAuthoring_tool;
+	return ref;
+}
+
+
+daeMetaElement *
+domAsset::domContributor::domAuthoring_tool::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "authoring_tool" );
+	_Meta->setStaticPointerAddress(&domAsset::domContributor::domAuthoring_tool::_Meta);
+	_Meta->registerConstructor(domAsset::domContributor::domAuthoring_tool::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domAsset::domContributor::domCommentsRef ref = new(bytes) domAsset::domContributor::domComments;
+	return ref;
+}
+
+
+daeMetaElement *
+domAsset::domContributor::domComments::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "comments" );
+	_Meta->setStaticPointerAddress(&domAsset::domContributor::domComments::_Meta);
+	_Meta->registerConstructor(domAsset::domContributor::domComments::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domAsset::domContributor::domCopyrightRef ref = new(bytes) domAsset::domContributor::domCopyright;
+	return ref;
+}
+
+
+daeMetaElement *
+domAsset::domContributor::domCopyright::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "copyright" );
+	_Meta->setStaticPointerAddress(&domAsset::domContributor::domCopyright::_Meta);
+	_Meta->registerConstructor(domAsset::domContributor::domCopyright::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domAsset::domContributor::domSource_dataRef ref = new(bytes) domAsset::domContributor::domSource_data;
+	ref->_value.setContainer( (domAsset::domContributor::domSource_data*)ref );
+	return ref;
+}
+
+
+daeMetaElement *
+domAsset::domContributor::domSource_data::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "source_data" );
+	_Meta->setStaticPointerAddress(&domAsset::domContributor::domSource_data::_Meta);
+	_Meta->registerConstructor(domAsset::domContributor::domSource_data::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domAsset::domCreatedRef ref = new(bytes) domAsset::domCreated;
+	return ref;
+}
+
+
+daeMetaElement *
+domAsset::domCreated::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "created" );
+	_Meta->setStaticPointerAddress(&domAsset::domCreated::_Meta);
+	_Meta->registerConstructor(domAsset::domCreated::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domAsset::domKeywordsRef ref = new(bytes) domAsset::domKeywords;
+	return ref;
+}
+
+
+daeMetaElement *
+domAsset::domKeywords::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "keywords" );
+	_Meta->setStaticPointerAddress(&domAsset::domKeywords::_Meta);
+	_Meta->registerConstructor(domAsset::domKeywords::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domAsset::domModifiedRef ref = new(bytes) domAsset::domModified;
+	return ref;
+}
+
+
+daeMetaElement *
+domAsset::domModified::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "modified" );
+	_Meta->setStaticPointerAddress(&domAsset::domModified::_Meta);
+	_Meta->registerConstructor(domAsset::domModified::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domAsset::domRevisionRef ref = new(bytes) domAsset::domRevision;
+	return ref;
+}
+
+
+daeMetaElement *
+domAsset::domRevision::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "revision" );
+	_Meta->setStaticPointerAddress(&domAsset::domRevision::_Meta);
+	_Meta->registerConstructor(domAsset::domRevision::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domAsset::domSubjectRef ref = new(bytes) domAsset::domSubject;
+	return ref;
+}
+
+
+daeMetaElement *
+domAsset::domSubject::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "subject" );
+	_Meta->setStaticPointerAddress(&domAsset::domSubject::_Meta);
+	_Meta->registerConstructor(domAsset::domSubject::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domAsset::domTitleRef ref = new(bytes) domAsset::domTitle;
+	return ref;
+}
+
+
+daeMetaElement *
+domAsset::domTitle::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "title" );
+	_Meta->setStaticPointerAddress(&domAsset::domTitle::_Meta);
+	_Meta->registerConstructor(domAsset::domTitle::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domAsset::domUnitRef ref = new(bytes) domAsset::domUnit;
+	return ref;
+}
+
+
+daeMetaElement *
+domAsset::domUnit::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "unit" );
+	_Meta->setStaticPointerAddress(&domAsset::domUnit::_Meta);
+	_Meta->registerConstructor(domAsset::domUnit::create);
+
+
+	//	Add attribute: meter
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "meter" );
+		ma->setType( daeAtomicType::get("Float"));
+		ma->setOffset( daeOffsetOf( domAsset::domUnit , attrMeter ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "1.0");
+	
+		_Meta->appendAttribute(ma);
+	}
+
+	//	Add attribute: name
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "name" );
+		ma->setType( daeAtomicType::get("xsNMTOKEN"));
+		ma->setOffset( daeOffsetOf( domAsset::domUnit , attrName ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "meter");
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domAsset::domUnit));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domAsset::domUp_axis::create(daeInt bytes)
+{
+	domAsset::domUp_axisRef ref = new(bytes) domAsset::domUp_axis;
+	return ref;
+}
+
+
+daeMetaElement *
+domAsset::domUp_axis::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "up_axis" );
+	_Meta->setStaticPointerAddress(&domAsset::domUp_axis::_Meta);
+	_Meta->registerConstructor(domAsset::domUp_axis::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domAsset::_Meta = NULL;
+daeMetaElement * domAsset::domContributor::_Meta = NULL;
+daeMetaElement * domAsset::domContributor::domAuthor::_Meta = NULL;
+daeMetaElement * domAsset::domContributor::domAuthoring_tool::_Meta = NULL;
+daeMetaElement * domAsset::domContributor::domComments::_Meta = NULL;
+daeMetaElement * domAsset::domContributor::domCopyright::_Meta = NULL;
+daeMetaElement * domAsset::domContributor::domSource_data::_Meta = NULL;
+daeMetaElement * domAsset::domCreated::_Meta = NULL;
+daeMetaElement * domAsset::domKeywords::_Meta = NULL;
+daeMetaElement * domAsset::domModified::_Meta = NULL;
+daeMetaElement * domAsset::domRevision::_Meta = NULL;
+daeMetaElement * domAsset::domSubject::_Meta = NULL;
+daeMetaElement * domAsset::domTitle::_Meta = NULL;
+daeMetaElement * domAsset::domUnit::_Meta = NULL;
+daeMetaElement * domAsset::domUp_axis::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domBind_material.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/daeDom.h>
+#include <dom/domBind_material.h>
+
+daeElementRef
+domBind_material::create(daeInt bytes)
+{
+	domBind_materialRef ref = new(bytes) domBind_material;
+	return ref;
+}
+
+
+daeMetaElement *
+domBind_material::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "bind_material" );
+	_Meta->setStaticPointerAddress(&domBind_material::_Meta);
+	_Meta->registerConstructor(domBind_material::create);
+
+	// Add elements: param, technique_common, technique
+    _Meta->appendArrayElement(domParam::registerElement(),daeOffsetOf(domBind_material,elemParam_array));
+    _Meta->appendElement(domBind_material::domTechnique_common::registerElement(),daeOffsetOf(domBind_material,elemTechnique_common));
+    _Meta->appendArrayElement(domTechnique::registerElement(),daeOffsetOf(domBind_material,elemTechnique_array));
+	
+	
+	_Meta->setElementSize(sizeof(domBind_material));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domBind_material::domTechnique_common::create(daeInt bytes)
+{
+	domBind_material::domTechnique_commonRef ref = new(bytes) domBind_material::domTechnique_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domBind_material::domTechnique_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "technique_common" );
+	_Meta->setStaticPointerAddress(&domBind_material::domTechnique_common::_Meta);
+	_Meta->registerConstructor(domBind_material::domTechnique_common::create);
+
+	// Add elements: instance_material
+    _Meta->appendArrayElement(domInstance_material::registerElement(),daeOffsetOf(domBind_material::domTechnique_common,elemInstance_material_array));
+	
+	
+	_Meta->setElementSize(sizeof(domBind_material::domTechnique_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domBind_material::_Meta = NULL;
+daeMetaElement * domBind_material::domTechnique_common::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domBool_array.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/daeDom.h>
+#include <dom/domBool_array.h>
+
+daeElementRef
+domBool_array::create(daeInt bytes)
+{
+	domBool_arrayRef ref = new(bytes) domBool_array;
+	return ref;
+}
+
+
+daeMetaElement *
+domBool_array::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "bool_array" );
+	_Meta->setStaticPointerAddress(&domBool_array::_Meta);
+	_Meta->registerConstructor(domBool_array::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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( daeAtomicType::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( daeAtomicType::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;
+}
+
+
+daeMetaElement * domBool_array::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domBox.cpp

@@ -0,0 +1,85 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domBox.h>
+
+daeElementRef
+domBox::create(daeInt bytes)
+{
+	domBoxRef ref = new(bytes) domBox;
+	return ref;
+}
+
+
+daeMetaElement *
+domBox::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "box" );
+	_Meta->setStaticPointerAddress(&domBox::_Meta);
+	_Meta->registerConstructor(domBox::create);
+
+	// Add elements: half_extents, extra
+    _Meta->appendElement(domBox::domHalf_extents::registerElement(),daeOffsetOf(domBox,elemHalf_extents));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domBox,elemExtra_array));
+	
+	
+	_Meta->setElementSize(sizeof(domBox));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domBox::domHalf_extents::create(daeInt bytes)
+{
+	domBox::domHalf_extentsRef ref = new(bytes) domBox::domHalf_extents;
+	return ref;
+}
+
+
+daeMetaElement *
+domBox::domHalf_extents::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "half_extents" );
+	_Meta->setStaticPointerAddress(&domBox::domHalf_extents::_Meta);
+	_Meta->registerConstructor(domBox::domHalf_extents::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domBox::_Meta = NULL;
+daeMetaElement * domBox::domHalf_extents::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCOLLADA.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/daeDom.h>
+#include <dom/domCOLLADA.h>
+
+extern daeString COLLADA_VERSION;
+extern daeString COLLADA_NAMESPACE;
+
+daeElementRef
+domCOLLADA::create(daeInt bytes)
+{
+	domCOLLADARef ref = new(bytes) domCOLLADA;
+	ref->attrXmlns.setContainer( (domCOLLADA*)ref );
+	ref->setAttribute("version", COLLADA_VERSION );
+	ref->setAttribute("xmlns", COLLADA_NAMESPACE );
+	return ref;
+}
+
+
+daeMetaElement *
+domCOLLADA::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "COLLADA" );
+	_Meta->setStaticPointerAddress(&domCOLLADA::_Meta);
+	_Meta->registerConstructor(domCOLLADA::create);
+
+	// Add elements: asset, library_animations, library_animation_clips, library_cameras, library_controllers, library_geometries, library_effects, library_force_fields, library_images, library_lights, library_materials, library_nodes, library_physics_materials, library_physics_models, library_physics_scenes, library_visual_scenes, scene, extra
+    _Meta->appendElement(domAsset::registerElement(),daeOffsetOf(domCOLLADA,elemAsset));
+    _Meta->appendArrayElement(domLibrary_animations::registerElement(),daeOffsetOf(domCOLLADA,elemLibrary_animations_array));
+    _Meta->appendArrayElement(domLibrary_animation_clips::registerElement(),daeOffsetOf(domCOLLADA,elemLibrary_animation_clips_array));
+    _Meta->appendArrayElement(domLibrary_cameras::registerElement(),daeOffsetOf(domCOLLADA,elemLibrary_cameras_array));
+    _Meta->appendArrayElement(domLibrary_controllers::registerElement(),daeOffsetOf(domCOLLADA,elemLibrary_controllers_array));
+    _Meta->appendArrayElement(domLibrary_geometries::registerElement(),daeOffsetOf(domCOLLADA,elemLibrary_geometries_array));
+    _Meta->appendArrayElement(domLibrary_effects::registerElement(),daeOffsetOf(domCOLLADA,elemLibrary_effects_array));
+    _Meta->appendArrayElement(domLibrary_force_fields::registerElement(),daeOffsetOf(domCOLLADA,elemLibrary_force_fields_array));
+    _Meta->appendArrayElement(domLibrary_images::registerElement(),daeOffsetOf(domCOLLADA,elemLibrary_images_array));
+    _Meta->appendArrayElement(domLibrary_lights::registerElement(),daeOffsetOf(domCOLLADA,elemLibrary_lights_array));
+    _Meta->appendArrayElement(domLibrary_materials::registerElement(),daeOffsetOf(domCOLLADA,elemLibrary_materials_array));
+    _Meta->appendArrayElement(domLibrary_nodes::registerElement(),daeOffsetOf(domCOLLADA,elemLibrary_nodes_array));
+    _Meta->appendArrayElement(domLibrary_physics_materials::registerElement(),daeOffsetOf(domCOLLADA,elemLibrary_physics_materials_array));
+    _Meta->appendArrayElement(domLibrary_physics_models::registerElement(),daeOffsetOf(domCOLLADA,elemLibrary_physics_models_array));
+    _Meta->appendArrayElement(domLibrary_physics_scenes::registerElement(),daeOffsetOf(domCOLLADA,elemLibrary_physics_scenes_array));
+    _Meta->appendArrayElement(domLibrary_visual_scenes::registerElement(),daeOffsetOf(domCOLLADA,elemLibrary_visual_scenes_array));
+    _Meta->appendElement(domCOLLADA::domScene::registerElement(),daeOffsetOf(domCOLLADA,elemScene));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domCOLLADA,elemExtra_array));
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domCOLLADA,_contents));
+
+    //	Add attribute: xmlns
+    {
+		daeMetaAttribute* ma = new daeMetaAttribute;
+		ma->setName( "xmlns" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("VersionType"));
+		ma->setOffset( daeOffsetOf( domCOLLADA , attrVersion ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domCOLLADA));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domCOLLADA::domScene::create(daeInt bytes)
+{
+	domCOLLADA::domSceneRef ref = new(bytes) domCOLLADA::domScene;
+	return ref;
+}
+
+
+daeMetaElement *
+domCOLLADA::domScene::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "scene" );
+	_Meta->setStaticPointerAddress(&domCOLLADA::domScene::_Meta);
+	_Meta->registerConstructor(domCOLLADA::domScene::create);
+
+	// Add elements: instance_physics_scene, instance_visual_scene, extra
+    _Meta->appendArrayElement(domInstanceWithExtra::registerElement(),daeOffsetOf(domCOLLADA::domScene,elemInstance_physics_scene_array),"instance_physics_scene"); 
+    _Meta->appendElement(domInstanceWithExtra::registerElement(),daeOffsetOf(domCOLLADA::domScene,elemInstance_visual_scene),"instance_visual_scene"); 
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domCOLLADA::domScene,elemExtra_array));
+	
+	
+	_Meta->setElementSize(sizeof(domCOLLADA::domScene));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domCOLLADA::_Meta = NULL;
+daeMetaElement * domCOLLADA::domScene::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCamera.cpp

@@ -0,0 +1,239 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCamera.h>
+
+daeElementRef
+domCamera::create(daeInt bytes)
+{
+	domCameraRef ref = new(bytes) domCamera;
+	return ref;
+}
+
+
+daeMetaElement *
+domCamera::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "camera" );
+	_Meta->setStaticPointerAddress(&domCamera::_Meta);
+	_Meta->registerConstructor(domCamera::create);
+
+	// Add elements: asset, optics, imager, extra
+    _Meta->appendElement(domAsset::registerElement(),daeOffsetOf(domCamera,elemAsset));
+    _Meta->appendElement(domCamera::domOptics::registerElement(),daeOffsetOf(domCamera,elemOptics));
+    _Meta->appendElement(domCamera::domImager::registerElement(),daeOffsetOf(domCamera,elemImager));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domCamera,elemExtra_array));
+
+	//	Add attribute: id
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "id" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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(daeInt bytes)
+{
+	domCamera::domOpticsRef ref = new(bytes) domCamera::domOptics;
+	return ref;
+}
+
+
+daeMetaElement *
+domCamera::domOptics::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "optics" );
+	_Meta->setStaticPointerAddress(&domCamera::domOptics::_Meta);
+	_Meta->registerConstructor(domCamera::domOptics::create);
+
+	// Add elements: technique_common, technique, extra
+    _Meta->appendElement(domCamera::domOptics::domTechnique_common::registerElement(),daeOffsetOf(domCamera::domOptics,elemTechnique_common));
+    _Meta->appendArrayElement(domTechnique::registerElement(),daeOffsetOf(domCamera::domOptics,elemTechnique_array));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domCamera::domOptics,elemExtra_array));
+	
+	
+	_Meta->setElementSize(sizeof(domCamera::domOptics));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domCamera::domOptics::domTechnique_common::create(daeInt bytes)
+{
+	domCamera::domOptics::domTechnique_commonRef ref = new(bytes) domCamera::domOptics::domTechnique_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domCamera::domOptics::domTechnique_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "technique_common" );
+	_Meta->setStaticPointerAddress(&domCamera::domOptics::domTechnique_common::_Meta);
+	_Meta->registerConstructor(domCamera::domOptics::domTechnique_common::create);
+
+	// Add elements: orthographic, perspective
+    _Meta->appendElement(domCamera::domOptics::domTechnique_common::domOrthographic::registerElement(),daeOffsetOf(domCamera::domOptics::domTechnique_common,elemOrthographic));
+    _Meta->appendElement(domCamera::domOptics::domTechnique_common::domPerspective::registerElement(),daeOffsetOf(domCamera::domOptics::domTechnique_common,elemPerspective));
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domCamera::domOptics::domTechnique_common,_contents));
+
+	
+	
+	_Meta->setElementSize(sizeof(domCamera::domOptics::domTechnique_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domCamera::domOptics::domTechnique_common::domOrthographic::create(daeInt bytes)
+{
+	domCamera::domOptics::domTechnique_common::domOrthographicRef ref = new(bytes) domCamera::domOptics::domTechnique_common::domOrthographic;
+	return ref;
+}
+
+
+daeMetaElement *
+domCamera::domOptics::domTechnique_common::domOrthographic::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "orthographic" );
+	_Meta->setStaticPointerAddress(&domCamera::domOptics::domTechnique_common::domOrthographic::_Meta);
+	_Meta->registerConstructor(domCamera::domOptics::domTechnique_common::domOrthographic::create);
+
+	// Add elements: xmag, ymag, aspect_ratio, znear, zfar
+    _Meta->appendElement(domTargetableFloat::registerElement(),daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,elemXmag),"xmag"); 
+    _Meta->appendElement(domTargetableFloat::registerElement(),daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,elemYmag),"ymag"); 
+    _Meta->appendElement(domTargetableFloat::registerElement(),daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,elemAspect_ratio),"aspect_ratio"); 
+    _Meta->appendElement(domTargetableFloat::registerElement(),daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,elemZnear),"znear"); 
+    _Meta->appendElement(domTargetableFloat::registerElement(),daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,elemZfar),"zfar"); 
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domCamera::domOptics::domTechnique_common::domOrthographic,_contents));
+
+	
+	
+	_Meta->setElementSize(sizeof(domCamera::domOptics::domTechnique_common::domOrthographic));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domCamera::domOptics::domTechnique_common::domPerspective::create(daeInt bytes)
+{
+	domCamera::domOptics::domTechnique_common::domPerspectiveRef ref = new(bytes) domCamera::domOptics::domTechnique_common::domPerspective;
+	return ref;
+}
+
+
+daeMetaElement *
+domCamera::domOptics::domTechnique_common::domPerspective::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "perspective" );
+	_Meta->setStaticPointerAddress(&domCamera::domOptics::domTechnique_common::domPerspective::_Meta);
+	_Meta->registerConstructor(domCamera::domOptics::domTechnique_common::domPerspective::create);
+
+	// Add elements: xfov, yfov, aspect_ratio, znear, zfar
+    _Meta->appendElement(domTargetableFloat::registerElement(),daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,elemXfov),"xfov"); 
+    _Meta->appendElement(domTargetableFloat::registerElement(),daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,elemYfov),"yfov"); 
+    _Meta->appendElement(domTargetableFloat::registerElement(),daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,elemAspect_ratio),"aspect_ratio"); 
+    _Meta->appendElement(domTargetableFloat::registerElement(),daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,elemZnear),"znear"); 
+    _Meta->appendElement(domTargetableFloat::registerElement(),daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,elemZfar),"zfar"); 
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domCamera::domOptics::domTechnique_common::domPerspective,_contents));
+
+	
+	
+	_Meta->setElementSize(sizeof(domCamera::domOptics::domTechnique_common::domPerspective));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domCamera::domImager::create(daeInt bytes)
+{
+	domCamera::domImagerRef ref = new(bytes) domCamera::domImager;
+	return ref;
+}
+
+
+daeMetaElement *
+domCamera::domImager::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "imager" );
+	_Meta->setStaticPointerAddress(&domCamera::domImager::_Meta);
+	_Meta->registerConstructor(domCamera::domImager::create);
+
+	// Add elements: technique, extra
+    _Meta->appendArrayElement(domTechnique::registerElement(),daeOffsetOf(domCamera::domImager,elemTechnique_array));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domCamera::domImager,elemExtra_array));
+	
+	
+	_Meta->setElementSize(sizeof(domCamera::domImager));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domCamera::_Meta = NULL;
+daeMetaElement * domCamera::domOptics::_Meta = NULL;
+daeMetaElement * domCamera::domOptics::domTechnique_common::_Meta = NULL;
+daeMetaElement * domCamera::domOptics::domTechnique_common::domOrthographic::_Meta = NULL;
+daeMetaElement * domCamera::domOptics::domTechnique_common::domPerspective::_Meta = NULL;
+daeMetaElement * domCamera::domImager::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCapsule.cpp

@@ -0,0 +1,122 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCapsule.h>
+
+daeElementRef
+domCapsule::create(daeInt bytes)
+{
+	domCapsuleRef ref = new(bytes) domCapsule;
+	return ref;
+}
+
+
+daeMetaElement *
+domCapsule::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "capsule" );
+	_Meta->setStaticPointerAddress(&domCapsule::_Meta);
+	_Meta->registerConstructor(domCapsule::create);
+
+	// Add elements: height, radius, extra
+    _Meta->appendElement(domCapsule::domHeight::registerElement(),daeOffsetOf(domCapsule,elemHeight));
+    _Meta->appendElement(domCapsule::domRadius::registerElement(),daeOffsetOf(domCapsule,elemRadius));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domCapsule,elemExtra_array));
+	
+	
+	_Meta->setElementSize(sizeof(domCapsule));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domCapsule::domHeight::create(daeInt bytes)
+{
+	domCapsule::domHeightRef ref = new(bytes) domCapsule::domHeight;
+	return ref;
+}
+
+
+daeMetaElement *
+domCapsule::domHeight::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "height" );
+	_Meta->setStaticPointerAddress(&domCapsule::domHeight::_Meta);
+	_Meta->registerConstructor(domCapsule::domHeight::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domCapsule::domRadiusRef ref = new(bytes) domCapsule::domRadius;
+	return ref;
+}
+
+
+daeMetaElement *
+domCapsule::domRadius::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "radius" );
+	_Meta->setStaticPointerAddress(&domCapsule::domRadius::_Meta);
+	_Meta->registerConstructor(domCapsule::domRadius::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::get("Float2"));
+		ma->setOffset( daeOffsetOf( domCapsule::domRadius , _value ));
+		ma->setContainer( _Meta );
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domCapsule::domRadius));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domCapsule::_Meta = NULL;
+daeMetaElement * domCapsule::domHeight::_Meta = NULL;
+daeMetaElement * domCapsule::domRadius::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCg_connect_param.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCg_connect_param.h>
+
+daeElementRef
+domCg_connect_param::create(daeInt bytes)
+{
+	domCg_connect_paramRef ref = new(bytes) domCg_connect_param;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_connect_param::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "cg_connect_param" );
+	_Meta->setStaticPointerAddress(&domCg_connect_param::_Meta);
+	_Meta->registerConstructor(domCg_connect_param::create);
+
+
+	//	Add attribute: ref
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "ref" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domCg_connect_param::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCg_newarray_type.cpp

@@ -0,0 +1,180 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCg_newarray_type.h>
+
+daeElementRef
+domCg_newarray_type::create(daeInt bytes)
+{
+	domCg_newarray_typeRef ref = new(bytes) domCg_newarray_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_newarray_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "cg_newarray_type" );
+	_Meta->setStaticPointerAddress(&domCg_newarray_type::_Meta);
+	_Meta->registerConstructor(domCg_newarray_type::create);
+
+	// Add elements: cg_param_type, array, usertype, connect_param
+    _Meta->appendArrayElement(domCg_param_type::registerElement(),daeOffsetOf(domCg_newarray_type,elemCg_param_type_array));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "surface", _Meta->getMetaElements()[0], "cg_surface_type");
+	_Meta->appendPossibleChild( "sampler1D", _Meta->getMetaElements()[0], "cg_sampler1D");
+	_Meta->appendPossibleChild( "sampler2D", _Meta->getMetaElements()[0], "cg_sampler2D");
+	_Meta->appendPossibleChild( "sampler3D", _Meta->getMetaElements()[0], "cg_sampler3D");
+	_Meta->appendPossibleChild( "samplerRECT", _Meta->getMetaElements()[0], "cg_samplerRECT");
+	_Meta->appendPossibleChild( "samplerCUBE", _Meta->getMetaElements()[0], "cg_samplerCUBE");
+	_Meta->appendPossibleChild( "samplerDEPTH", _Meta->getMetaElements()[0], "cg_samplerDEPTH");
+	_Meta->appendPossibleChild( "string", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "enum", _Meta->getMetaElements()[0]);
+    _Meta->appendArrayElement(domCg_newarray_type::registerElement(),daeOffsetOf(domCg_newarray_type,elemArray_array),"array"); 
+    _Meta->appendArrayElement(domCg_setuser_type::registerElement(),daeOffsetOf(domCg_newarray_type,elemUsertype_array),"usertype"); 
+    _Meta->appendArrayElement(domCg_connect_param::registerElement(),daeOffsetOf(domCg_newarray_type,elemConnect_param_array),"connect_param"); 
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domCg_newarray_type,_contents));
+
+
+	//	Add attribute: length
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "length" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domCg_newarray_type::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCg_newparam.cpp

@@ -0,0 +1,254 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCg_newparam.h>
+
+daeElementRef
+domCg_newparam::create(daeInt bytes)
+{
+	domCg_newparamRef ref = new(bytes) domCg_newparam;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_newparam::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "cg_newparam" );
+	_Meta->setStaticPointerAddress(&domCg_newparam::_Meta);
+	_Meta->registerConstructor(domCg_newparam::create);
+
+	// Add elements: annotate, semantic, modifier, cg_param_type, usertype, array
+    _Meta->appendArrayElement(domFx_annotate_common::registerElement(),daeOffsetOf(domCg_newparam,elemAnnotate_array),"annotate"); 
+    _Meta->appendElement(domCg_newparam::domSemantic::registerElement(),daeOffsetOf(domCg_newparam,elemSemantic));
+    _Meta->appendElement(domCg_newparam::domModifier::registerElement(),daeOffsetOf(domCg_newparam,elemModifier));
+    _Meta->appendElement(domCg_param_type::registerElement(),daeOffsetOf(domCg_newparam,elemCg_param_type));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool1x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool1x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool1x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool1x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool2x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool2x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool2x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool2x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool3x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool3x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool3x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool3x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool4x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool4x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool4x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool4x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float1x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float1x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float1x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float1x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int1x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int1x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int1x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int1x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int2x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int2x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int2x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int2x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int3x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int3x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int3x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int3x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int4x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int4x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int4x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int4x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half1x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half1x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half1x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half1x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half2x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half2x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half2x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half2x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half3x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half3x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half3x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half3x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half4x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half4x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half4x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "half4x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed1x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed1x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed1x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed1x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed2x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed2x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed2x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed2x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed3x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed3x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed3x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed3x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed4x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed4x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed4x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "fixed4x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "surface", _Meta->getMetaElements()[3], "cg_surface_type");
+	_Meta->appendPossibleChild( "sampler1D", _Meta->getMetaElements()[3], "cg_sampler1D");
+	_Meta->appendPossibleChild( "sampler2D", _Meta->getMetaElements()[3], "cg_sampler2D");
+	_Meta->appendPossibleChild( "sampler3D", _Meta->getMetaElements()[3], "cg_sampler3D");
+	_Meta->appendPossibleChild( "samplerRECT", _Meta->getMetaElements()[3], "cg_samplerRECT");
+	_Meta->appendPossibleChild( "samplerCUBE", _Meta->getMetaElements()[3], "cg_samplerCUBE");
+	_Meta->appendPossibleChild( "samplerDEPTH", _Meta->getMetaElements()[3], "cg_samplerDEPTH");
+	_Meta->appendPossibleChild( "string", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "enum", _Meta->getMetaElements()[3]);
+    _Meta->appendElement(domCg_setuser_type::registerElement(),daeOffsetOf(domCg_newparam,elemUsertype),"usertype"); 
+    _Meta->appendElement(domCg_newarray_type::registerElement(),daeOffsetOf(domCg_newparam,elemArray),"array"); 
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domCg_newparam,_contents));
+
+
+	//	Add attribute: sid
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "sid" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domCg_newparam::domSemanticRef ref = new(bytes) domCg_newparam::domSemantic;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_newparam::domSemantic::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "semantic" );
+	_Meta->setStaticPointerAddress(&domCg_newparam::domSemantic::_Meta);
+	_Meta->registerConstructor(domCg_newparam::domSemantic::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domCg_newparam::domModifierRef ref = new(bytes) domCg_newparam::domModifier;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_newparam::domModifier::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "modifier" );
+	_Meta->setStaticPointerAddress(&domCg_newparam::domModifier::_Meta);
+	_Meta->registerConstructor(domCg_newparam::domModifier::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domCg_newparam::_Meta = NULL;
+daeMetaElement * domCg_newparam::domSemantic::_Meta = NULL;
+daeMetaElement * domCg_newparam::domModifier::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCg_sampler1D.cpp

@@ -0,0 +1,55 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCg_sampler1D.h>
+
+daeElementRef
+domCg_sampler1D::create(daeInt bytes)
+{
+	domCg_sampler1DRef ref = new(bytes) domCg_sampler1D;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_sampler1D::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "cg_sampler1D" );
+	_Meta->setStaticPointerAddress(&domCg_sampler1D::_Meta);
+	_Meta->registerConstructor(domCg_sampler1D::create);
+
+	// Add elements: source, wrap_s, minfilter, magfilter, mipfilter, border_color, mipmap_maxlevel, mipmap_bias
+    _Meta->appendElement(domSource::registerElement(),daeOffsetOf(domCg_sampler1D,elemSource));
+    _Meta->appendElement(domWrap_s::registerElement(),daeOffsetOf(domCg_sampler1D,elemWrap_s));
+    _Meta->appendElement(domMinfilter::registerElement(),daeOffsetOf(domCg_sampler1D,elemMinfilter));
+    _Meta->appendElement(domMagfilter::registerElement(),daeOffsetOf(domCg_sampler1D,elemMagfilter));
+    _Meta->appendElement(domMipfilter::registerElement(),daeOffsetOf(domCg_sampler1D,elemMipfilter));
+    _Meta->appendElement(domBorder_color::registerElement(),daeOffsetOf(domCg_sampler1D,elemBorder_color));
+    _Meta->appendElement(domMipmap_maxlevel::registerElement(),daeOffsetOf(domCg_sampler1D,elemMipmap_maxlevel));
+    _Meta->appendElement(domMipmap_bias::registerElement(),daeOffsetOf(domCg_sampler1D,elemMipmap_bias));
+	
+	
+	_Meta->setElementSize(sizeof(domCg_sampler1D));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domCg_sampler1D::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCg_sampler2D.cpp

@@ -0,0 +1,56 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCg_sampler2D.h>
+
+daeElementRef
+domCg_sampler2D::create(daeInt bytes)
+{
+	domCg_sampler2DRef ref = new(bytes) domCg_sampler2D;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_sampler2D::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "cg_sampler2D" );
+	_Meta->setStaticPointerAddress(&domCg_sampler2D::_Meta);
+	_Meta->registerConstructor(domCg_sampler2D::create);
+
+	// Add elements: source, wrap_s, wrap_t, minfilter, magfilter, mipfilter, border_color, mipmap_maxlevel, mipmap_bias
+    _Meta->appendElement(domSource::registerElement(),daeOffsetOf(domCg_sampler2D,elemSource));
+    _Meta->appendElement(domWrap_s::registerElement(),daeOffsetOf(domCg_sampler2D,elemWrap_s));
+    _Meta->appendElement(domWrap_t::registerElement(),daeOffsetOf(domCg_sampler2D,elemWrap_t));
+    _Meta->appendElement(domMinfilter::registerElement(),daeOffsetOf(domCg_sampler2D,elemMinfilter));
+    _Meta->appendElement(domMagfilter::registerElement(),daeOffsetOf(domCg_sampler2D,elemMagfilter));
+    _Meta->appendElement(domMipfilter::registerElement(),daeOffsetOf(domCg_sampler2D,elemMipfilter));
+    _Meta->appendElement(domBorder_color::registerElement(),daeOffsetOf(domCg_sampler2D,elemBorder_color));
+    _Meta->appendElement(domMipmap_maxlevel::registerElement(),daeOffsetOf(domCg_sampler2D,elemMipmap_maxlevel));
+    _Meta->appendElement(domMipmap_bias::registerElement(),daeOffsetOf(domCg_sampler2D,elemMipmap_bias));
+	
+	
+	_Meta->setElementSize(sizeof(domCg_sampler2D));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domCg_sampler2D::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCg_sampler3D.cpp

@@ -0,0 +1,57 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCg_sampler3D.h>
+
+daeElementRef
+domCg_sampler3D::create(daeInt bytes)
+{
+	domCg_sampler3DRef ref = new(bytes) domCg_sampler3D;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_sampler3D::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "cg_sampler3D" );
+	_Meta->setStaticPointerAddress(&domCg_sampler3D::_Meta);
+	_Meta->registerConstructor(domCg_sampler3D::create);
+
+	// Add elements: source, wrap_s, wrap_t, wrap_p, minfilter, magfilter, mipfilter, border_color, mipmap_maxlevel, mipmap_bias
+    _Meta->appendElement(domSource::registerElement(),daeOffsetOf(domCg_sampler3D,elemSource));
+    _Meta->appendElement(domWrap_s::registerElement(),daeOffsetOf(domCg_sampler3D,elemWrap_s));
+    _Meta->appendElement(domWrap_t::registerElement(),daeOffsetOf(domCg_sampler3D,elemWrap_t));
+    _Meta->appendElement(domWrap_p::registerElement(),daeOffsetOf(domCg_sampler3D,elemWrap_p));
+    _Meta->appendElement(domMinfilter::registerElement(),daeOffsetOf(domCg_sampler3D,elemMinfilter));
+    _Meta->appendElement(domMagfilter::registerElement(),daeOffsetOf(domCg_sampler3D,elemMagfilter));
+    _Meta->appendElement(domMipfilter::registerElement(),daeOffsetOf(domCg_sampler3D,elemMipfilter));
+    _Meta->appendElement(domBorder_color::registerElement(),daeOffsetOf(domCg_sampler3D,elemBorder_color));
+    _Meta->appendElement(domMipmap_maxlevel::registerElement(),daeOffsetOf(domCg_sampler3D,elemMipmap_maxlevel));
+    _Meta->appendElement(domMipmap_bias::registerElement(),daeOffsetOf(domCg_sampler3D,elemMipmap_bias));
+	
+	
+	_Meta->setElementSize(sizeof(domCg_sampler3D));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domCg_sampler3D::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCg_samplerCUBE.cpp

@@ -0,0 +1,57 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCg_samplerCUBE.h>
+
+daeElementRef
+domCg_samplerCUBE::create(daeInt bytes)
+{
+	domCg_samplerCUBERef ref = new(bytes) domCg_samplerCUBE;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_samplerCUBE::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "cg_samplerCUBE" );
+	_Meta->setStaticPointerAddress(&domCg_samplerCUBE::_Meta);
+	_Meta->registerConstructor(domCg_samplerCUBE::create);
+
+	// Add elements: source, wrap_s, wrap_t, wrap_p, minfilter, magfilter, mipfilter, border_color, mipmap_maxlevel, mipmap_bias
+    _Meta->appendElement(domSource::registerElement(),daeOffsetOf(domCg_samplerCUBE,elemSource));
+    _Meta->appendElement(domWrap_s::registerElement(),daeOffsetOf(domCg_samplerCUBE,elemWrap_s));
+    _Meta->appendElement(domWrap_t::registerElement(),daeOffsetOf(domCg_samplerCUBE,elemWrap_t));
+    _Meta->appendElement(domWrap_p::registerElement(),daeOffsetOf(domCg_samplerCUBE,elemWrap_p));
+    _Meta->appendElement(domMinfilter::registerElement(),daeOffsetOf(domCg_samplerCUBE,elemMinfilter));
+    _Meta->appendElement(domMagfilter::registerElement(),daeOffsetOf(domCg_samplerCUBE,elemMagfilter));
+    _Meta->appendElement(domMipfilter::registerElement(),daeOffsetOf(domCg_samplerCUBE,elemMipfilter));
+    _Meta->appendElement(domBorder_color::registerElement(),daeOffsetOf(domCg_samplerCUBE,elemBorder_color));
+    _Meta->appendElement(domMipmap_maxlevel::registerElement(),daeOffsetOf(domCg_samplerCUBE,elemMipmap_maxlevel));
+    _Meta->appendElement(domMipmap_bias::registerElement(),daeOffsetOf(domCg_samplerCUBE,elemMipmap_bias));
+	
+	
+	_Meta->setElementSize(sizeof(domCg_samplerCUBE));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domCg_samplerCUBE::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCg_samplerDEPTH.cpp

@@ -0,0 +1,52 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCg_samplerDEPTH.h>
+
+daeElementRef
+domCg_samplerDEPTH::create(daeInt bytes)
+{
+	domCg_samplerDEPTHRef ref = new(bytes) domCg_samplerDEPTH;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_samplerDEPTH::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "cg_samplerDEPTH" );
+	_Meta->setStaticPointerAddress(&domCg_samplerDEPTH::_Meta);
+	_Meta->registerConstructor(domCg_samplerDEPTH::create);
+
+	// Add elements: source, wrap_s, wrap_t, minfilter, magfilter
+    _Meta->appendElement(domSource::registerElement(),daeOffsetOf(domCg_samplerDEPTH,elemSource));
+    _Meta->appendElement(domWrap_s::registerElement(),daeOffsetOf(domCg_samplerDEPTH,elemWrap_s));
+    _Meta->appendElement(domWrap_t::registerElement(),daeOffsetOf(domCg_samplerDEPTH,elemWrap_t));
+    _Meta->appendElement(domMinfilter::registerElement(),daeOffsetOf(domCg_samplerDEPTH,elemMinfilter));
+    _Meta->appendElement(domMagfilter::registerElement(),daeOffsetOf(domCg_samplerDEPTH,elemMagfilter));
+	
+	
+	_Meta->setElementSize(sizeof(domCg_samplerDEPTH));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domCg_samplerDEPTH::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCg_samplerRECT.cpp

@@ -0,0 +1,56 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCg_samplerRECT.h>
+
+daeElementRef
+domCg_samplerRECT::create(daeInt bytes)
+{
+	domCg_samplerRECTRef ref = new(bytes) domCg_samplerRECT;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_samplerRECT::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "cg_samplerRECT" );
+	_Meta->setStaticPointerAddress(&domCg_samplerRECT::_Meta);
+	_Meta->registerConstructor(domCg_samplerRECT::create);
+
+	// Add elements: source, wrap_s, wrap_t, minfilter, magfilter, mipfilter, border_color, mipmap_maxlevel, mipmap_bias
+    _Meta->appendElement(domSource::registerElement(),daeOffsetOf(domCg_samplerRECT,elemSource));
+    _Meta->appendElement(domWrap_s::registerElement(),daeOffsetOf(domCg_samplerRECT,elemWrap_s));
+    _Meta->appendElement(domWrap_t::registerElement(),daeOffsetOf(domCg_samplerRECT,elemWrap_t));
+    _Meta->appendElement(domMinfilter::registerElement(),daeOffsetOf(domCg_samplerRECT,elemMinfilter));
+    _Meta->appendElement(domMagfilter::registerElement(),daeOffsetOf(domCg_samplerRECT,elemMagfilter));
+    _Meta->appendElement(domMipfilter::registerElement(),daeOffsetOf(domCg_samplerRECT,elemMipfilter));
+    _Meta->appendElement(domBorder_color::registerElement(),daeOffsetOf(domCg_samplerRECT,elemBorder_color));
+    _Meta->appendElement(domMipmap_maxlevel::registerElement(),daeOffsetOf(domCg_samplerRECT,elemMipmap_maxlevel));
+    _Meta->appendElement(domMipmap_bias::registerElement(),daeOffsetOf(domCg_samplerRECT,elemMipmap_bias));
+	
+	
+	_Meta->setElementSize(sizeof(domCg_samplerRECT));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domCg_samplerRECT::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCg_setarray_type.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/daeDom.h>
+#include <dom/domCg_setarray_type.h>
+
+daeElementRef
+domCg_setarray_type::create(daeInt bytes)
+{
+	domCg_setarray_typeRef ref = new(bytes) domCg_setarray_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_setarray_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "cg_setarray_type" );
+	_Meta->setStaticPointerAddress(&domCg_setarray_type::_Meta);
+	_Meta->registerConstructor(domCg_setarray_type::create);
+
+	// Add elements: cg_param_type, array, usertype
+    _Meta->appendArrayElement(domCg_param_type::registerElement(),daeOffsetOf(domCg_setarray_type,elemCg_param_type_array));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "surface", _Meta->getMetaElements()[0], "cg_surface_type");
+	_Meta->appendPossibleChild( "sampler1D", _Meta->getMetaElements()[0], "cg_sampler1D");
+	_Meta->appendPossibleChild( "sampler2D", _Meta->getMetaElements()[0], "cg_sampler2D");
+	_Meta->appendPossibleChild( "sampler3D", _Meta->getMetaElements()[0], "cg_sampler3D");
+	_Meta->appendPossibleChild( "samplerRECT", _Meta->getMetaElements()[0], "cg_samplerRECT");
+	_Meta->appendPossibleChild( "samplerCUBE", _Meta->getMetaElements()[0], "cg_samplerCUBE");
+	_Meta->appendPossibleChild( "samplerDEPTH", _Meta->getMetaElements()[0], "cg_samplerDEPTH");
+	_Meta->appendPossibleChild( "string", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "enum", _Meta->getMetaElements()[0]);
+    _Meta->appendArrayElement(domCg_setarray_type::registerElement(),daeOffsetOf(domCg_setarray_type,elemArray_array),"array"); 
+    _Meta->appendArrayElement(domCg_setuser_type::registerElement(),daeOffsetOf(domCg_setarray_type,elemUsertype_array),"usertype"); 
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domCg_setarray_type,_contents));
+
+
+	//	Add attribute: length
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "length" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domCg_setarray_type::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCg_setparam.cpp

@@ -0,0 +1,191 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCg_setparam.h>
+
+daeElementRef
+domCg_setparam::create(daeInt bytes)
+{
+	domCg_setparamRef ref = new(bytes) domCg_setparam;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_setparam::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "cg_setparam" );
+	_Meta->setStaticPointerAddress(&domCg_setparam::_Meta);
+	_Meta->registerConstructor(domCg_setparam::create);
+
+	// Add elements: cg_param_type, usertype, array, connect_param
+    _Meta->appendElement(domCg_param_type::registerElement(),daeOffsetOf(domCg_setparam,elemCg_param_type));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "surface", _Meta->getMetaElements()[0], "cg_surface_type");
+	_Meta->appendPossibleChild( "sampler1D", _Meta->getMetaElements()[0], "cg_sampler1D");
+	_Meta->appendPossibleChild( "sampler2D", _Meta->getMetaElements()[0], "cg_sampler2D");
+	_Meta->appendPossibleChild( "sampler3D", _Meta->getMetaElements()[0], "cg_sampler3D");
+	_Meta->appendPossibleChild( "samplerRECT", _Meta->getMetaElements()[0], "cg_samplerRECT");
+	_Meta->appendPossibleChild( "samplerCUBE", _Meta->getMetaElements()[0], "cg_samplerCUBE");
+	_Meta->appendPossibleChild( "samplerDEPTH", _Meta->getMetaElements()[0], "cg_samplerDEPTH");
+	_Meta->appendPossibleChild( "string", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "enum", _Meta->getMetaElements()[0]);
+    _Meta->appendElement(domCg_setuser_type::registerElement(),daeOffsetOf(domCg_setparam,elemUsertype),"usertype"); 
+    _Meta->appendElement(domCg_setarray_type::registerElement(),daeOffsetOf(domCg_setparam,elemArray),"array"); 
+    _Meta->appendElement(domCg_connect_param::registerElement(),daeOffsetOf(domCg_setparam,elemConnect_param),"connect_param"); 
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domCg_setparam,_contents));
+
+
+	//	Add attribute: ref
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "ref" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("xsNCName"));
+		ma->setOffset( daeOffsetOf( domCg_setparam , attrProgram ));
+		ma->setContainer( _Meta );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domCg_setparam));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domCg_setparam::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCg_setparam_simple.cpp

@@ -0,0 +1,175 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCg_setparam_simple.h>
+
+daeElementRef
+domCg_setparam_simple::create(daeInt bytes)
+{
+	domCg_setparam_simpleRef ref = new(bytes) domCg_setparam_simple;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_setparam_simple::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "cg_setparam_simple" );
+	_Meta->setStaticPointerAddress(&domCg_setparam_simple::_Meta);
+	_Meta->registerConstructor(domCg_setparam_simple::create);
+
+	// Add elements: annotate, cg_param_type
+    _Meta->appendArrayElement(domFx_annotate_common::registerElement(),daeOffsetOf(domCg_setparam_simple,elemAnnotate_array),"annotate"); 
+    _Meta->appendElement(domCg_param_type::registerElement(),daeOffsetOf(domCg_setparam_simple,elemCg_param_type));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool1x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool1x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool1x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool1x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool2x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool2x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool2x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool2x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool3x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool3x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool3x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool3x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool4x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool4x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool4x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool4x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float1x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float1x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float1x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float1x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float2x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float2x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float2x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float3x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float3x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float3x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float4x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float4x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float4x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int1x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int1x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int1x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int1x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int2x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int2x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int2x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int2x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int3x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int3x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int3x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int3x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int4x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int4x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int4x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int4x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half1x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half1x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half1x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half1x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half2x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half2x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half2x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half2x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half3x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half3x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half3x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half3x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half4x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half4x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half4x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "half4x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed1x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed1x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed1x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed1x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed2x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed2x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed2x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed2x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed3x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed3x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed3x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed3x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed4x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed4x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed4x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "fixed4x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "surface", _Meta->getMetaElements()[1], "cg_surface_type");
+	_Meta->appendPossibleChild( "sampler1D", _Meta->getMetaElements()[1], "cg_sampler1D");
+	_Meta->appendPossibleChild( "sampler2D", _Meta->getMetaElements()[1], "cg_sampler2D");
+	_Meta->appendPossibleChild( "sampler3D", _Meta->getMetaElements()[1], "cg_sampler3D");
+	_Meta->appendPossibleChild( "samplerRECT", _Meta->getMetaElements()[1], "cg_samplerRECT");
+	_Meta->appendPossibleChild( "samplerCUBE", _Meta->getMetaElements()[1], "cg_samplerCUBE");
+	_Meta->appendPossibleChild( "samplerDEPTH", _Meta->getMetaElements()[1], "cg_samplerDEPTH");
+	_Meta->appendPossibleChild( "string", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "enum", _Meta->getMetaElements()[1]);
+
+	//	Add attribute: ref
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "ref" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domCg_setparam_simple::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCg_setuser_type.cpp

@@ -0,0 +1,180 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCg_setuser_type.h>
+
+daeElementRef
+domCg_setuser_type::create(daeInt bytes)
+{
+	domCg_setuser_typeRef ref = new(bytes) domCg_setuser_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_setuser_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "cg_setuser_type" );
+	_Meta->setStaticPointerAddress(&domCg_setuser_type::_Meta);
+	_Meta->registerConstructor(domCg_setuser_type::create);
+
+	// Add elements: cg_param_type, array, usertype, connect_param
+    _Meta->appendArrayElement(domCg_param_type::registerElement(),daeOffsetOf(domCg_setuser_type,elemCg_param_type_array));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "half4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "fixed4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "surface", _Meta->getMetaElements()[0], "cg_surface_type");
+	_Meta->appendPossibleChild( "sampler1D", _Meta->getMetaElements()[0], "cg_sampler1D");
+	_Meta->appendPossibleChild( "sampler2D", _Meta->getMetaElements()[0], "cg_sampler2D");
+	_Meta->appendPossibleChild( "sampler3D", _Meta->getMetaElements()[0], "cg_sampler3D");
+	_Meta->appendPossibleChild( "samplerRECT", _Meta->getMetaElements()[0], "cg_samplerRECT");
+	_Meta->appendPossibleChild( "samplerCUBE", _Meta->getMetaElements()[0], "cg_samplerCUBE");
+	_Meta->appendPossibleChild( "samplerDEPTH", _Meta->getMetaElements()[0], "cg_samplerDEPTH");
+	_Meta->appendPossibleChild( "string", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "enum", _Meta->getMetaElements()[0]);
+    _Meta->appendArrayElement(domCg_setarray_type::registerElement(),daeOffsetOf(domCg_setuser_type,elemArray_array),"array"); 
+    _Meta->appendArrayElement(domCg_setuser_type::registerElement(),daeOffsetOf(domCg_setuser_type,elemUsertype_array),"usertype"); 
+    _Meta->appendArrayElement(domCg_connect_param::registerElement(),daeOffsetOf(domCg_setuser_type,elemConnect_param_array),"connect_param"); 
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domCg_setuser_type,_contents));
+
+
+	//	Add attribute: name
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "name" );
+		ma->setType( daeAtomicType::get("Cg_identifier"));
+		ma->setOffset( daeOffsetOf( domCg_setuser_type , attrName ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domCg_setuser_type));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domCg_setuser_type::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCg_surface_type.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/daeDom.h>
+#include <dom/domCg_surface_type.h>
+
+daeElementRef
+domCg_surface_type::create(daeInt bytes)
+{
+	domCg_surface_typeRef ref = new(bytes) domCg_surface_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_surface_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "cg_surface_type" );
+	_Meta->setStaticPointerAddress(&domCg_surface_type::_Meta);
+	_Meta->registerConstructor(domCg_surface_type::create);
+
+	// Add elements: init_from, format, size, viewport_ratio, mip_levels, mipmap_generate, generator
+    _Meta->appendArrayElement(domInit_from::registerElement(),daeOffsetOf(domCg_surface_type,elemInit_from_array));
+    _Meta->appendElement(domFormat::registerElement(),daeOffsetOf(domCg_surface_type,elemFormat));
+    _Meta->appendElement(domSize::registerElement(),daeOffsetOf(domCg_surface_type,elemSize));
+    _Meta->appendElement(domViewport_ratio::registerElement(),daeOffsetOf(domCg_surface_type,elemViewport_ratio));
+    _Meta->appendElement(domMip_levels::registerElement(),daeOffsetOf(domCg_surface_type,elemMip_levels));
+    _Meta->appendElement(domMipmap_generate::registerElement(),daeOffsetOf(domCg_surface_type,elemMipmap_generate));
+    _Meta->appendElement(domGenerator::registerElement(),daeOffsetOf(domCg_surface_type,elemGenerator));
+
+	//	Add attribute: type
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "type" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domCg_surface_type::domGeneratorRef ref = new(bytes) domCg_surface_type::domGenerator;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_surface_type::domGenerator::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "generator" );
+	_Meta->setStaticPointerAddress(&domCg_surface_type::domGenerator::_Meta);
+	_Meta->registerConstructor(domCg_surface_type::domGenerator::create);
+
+	// Add elements: annotate, code, include, name, setparam
+    _Meta->appendArrayElement(domFx_annotate_common::registerElement(),daeOffsetOf(domCg_surface_type::domGenerator,elemAnnotate_array),"annotate"); 
+    _Meta->appendArrayElement(domFx_code_profile::registerElement(),daeOffsetOf(domCg_surface_type::domGenerator,elemCode_array),"code"); 
+    _Meta->appendArrayElement(domFx_include_common::registerElement(),daeOffsetOf(domCg_surface_type::domGenerator,elemInclude_array),"include"); 
+    _Meta->appendElement(domCg_surface_type::domGenerator::domName::registerElement(),daeOffsetOf(domCg_surface_type::domGenerator,elemName));
+    _Meta->appendArrayElement(domCg_setparam_simple::registerElement(),daeOffsetOf(domCg_surface_type::domGenerator,elemSetparam_array),"setparam"); 
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domCg_surface_type::domGenerator,_contents));
+
+	
+	
+	_Meta->setElementSize(sizeof(domCg_surface_type::domGenerator));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domCg_surface_type::domGenerator::domName::create(daeInt bytes)
+{
+	domCg_surface_type::domGenerator::domNameRef ref = new(bytes) domCg_surface_type::domGenerator::domName;
+	return ref;
+}
+
+
+daeMetaElement *
+domCg_surface_type::domGenerator::domName::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "name" );
+	_Meta->setStaticPointerAddress(&domCg_surface_type::domGenerator::domName::_Meta);
+	_Meta->registerConstructor(domCg_surface_type::domGenerator::domName::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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;
+}
+
+
+daeMetaElement * domCg_surface_type::_Meta = NULL;
+daeMetaElement * domCg_surface_type::domGenerator::_Meta = NULL;
+daeMetaElement * domCg_surface_type::domGenerator::domName::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domChannel.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/daeDom.h>
+#include <dom/domChannel.h>
+
+daeElementRef
+domChannel::create(daeInt bytes)
+{
+	domChannelRef ref = new(bytes) domChannel;
+	ref->attrSource.setContainer( (domChannel*)ref );
+	return ref;
+}
+
+
+daeMetaElement *
+domChannel::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "channel" );
+	_Meta->setStaticPointerAddress(&domChannel::_Meta);
+	_Meta->registerConstructor(domChannel::create);
+
+
+	//	Add attribute: source
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "source" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("xsToken"));
+		ma->setOffset( daeOffsetOf( domChannel , attrTarget ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domChannel));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domChannel::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCommon_color_or_texture_type.cpp

@@ -0,0 +1,192 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCommon_color_or_texture_type.h>
+
+daeElementRef
+domCommon_color_or_texture_type::create(daeInt bytes)
+{
+	domCommon_color_or_texture_typeRef ref = new(bytes) domCommon_color_or_texture_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domCommon_color_or_texture_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "common_color_or_texture_type" );
+	_Meta->setStaticPointerAddress(&domCommon_color_or_texture_type::_Meta);
+	_Meta->registerConstructor(domCommon_color_or_texture_type::create);
+
+	// Add elements: color, param, texture
+    _Meta->appendElement(domCommon_color_or_texture_type::domColor::registerElement(),daeOffsetOf(domCommon_color_or_texture_type,elemColor));
+    _Meta->appendElement(domCommon_color_or_texture_type::domParam::registerElement(),daeOffsetOf(domCommon_color_or_texture_type,elemParam));
+    _Meta->appendElement(domCommon_color_or_texture_type::domTexture::registerElement(),daeOffsetOf(domCommon_color_or_texture_type,elemTexture));
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domCommon_color_or_texture_type,_contents));
+
+	
+	
+	_Meta->setElementSize(sizeof(domCommon_color_or_texture_type));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domCommon_color_or_texture_type::domColor::create(daeInt bytes)
+{
+	domCommon_color_or_texture_type::domColorRef ref = new(bytes) domCommon_color_or_texture_type::domColor;
+	return ref;
+}
+
+
+daeMetaElement *
+domCommon_color_or_texture_type::domColor::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "color" );
+	_Meta->setStaticPointerAddress(&domCommon_color_or_texture_type::domColor::_Meta);
+	_Meta->registerConstructor(domCommon_color_or_texture_type::domColor::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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(daeInt bytes)
+{
+	domCommon_color_or_texture_type::domParamRef ref = new(bytes) domCommon_color_or_texture_type::domParam;
+	return ref;
+}
+
+
+daeMetaElement *
+domCommon_color_or_texture_type::domParam::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "param" );
+	_Meta->setStaticPointerAddress(&domCommon_color_or_texture_type::domParam::_Meta);
+	_Meta->registerConstructor(domCommon_color_or_texture_type::domParam::create);
+
+
+	//	Add attribute: ref
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "ref" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domCommon_color_or_texture_type::domTextureRef ref = new(bytes) domCommon_color_or_texture_type::domTexture;
+	return ref;
+}
+
+
+daeMetaElement *
+domCommon_color_or_texture_type::domTexture::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "texture" );
+	_Meta->setStaticPointerAddress(&domCommon_color_or_texture_type::domTexture::_Meta);
+	_Meta->registerConstructor(domCommon_color_or_texture_type::domTexture::create);
+
+	// Add elements: extra
+    _Meta->appendElement(domExtra::registerElement(),daeOffsetOf(domCommon_color_or_texture_type::domTexture,elemExtra));
+
+	//	Add attribute: texture
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "texture" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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;
+}
+
+
+daeMetaElement * domCommon_color_or_texture_type::_Meta = NULL;
+daeMetaElement * domCommon_color_or_texture_type::domColor::_Meta = NULL;
+daeMetaElement * domCommon_color_or_texture_type::domParam::_Meta = NULL;
+daeMetaElement * domCommon_color_or_texture_type::domTexture::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCommon_float_or_param_type.cpp

@@ -0,0 +1,138 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCommon_float_or_param_type.h>
+
+daeElementRef
+domCommon_float_or_param_type::create(daeInt bytes)
+{
+	domCommon_float_or_param_typeRef ref = new(bytes) domCommon_float_or_param_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domCommon_float_or_param_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "common_float_or_param_type" );
+	_Meta->setStaticPointerAddress(&domCommon_float_or_param_type::_Meta);
+	_Meta->registerConstructor(domCommon_float_or_param_type::create);
+
+	// Add elements: float, param
+    _Meta->appendElement(domCommon_float_or_param_type::domFloat::registerElement(),daeOffsetOf(domCommon_float_or_param_type,elemFloat));
+    _Meta->appendElement(domCommon_float_or_param_type::domParam::registerElement(),daeOffsetOf(domCommon_float_or_param_type,elemParam));
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domCommon_float_or_param_type,_contents));
+
+	
+	
+	_Meta->setElementSize(sizeof(domCommon_float_or_param_type));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domCommon_float_or_param_type::domFloat::create(daeInt bytes)
+{
+	domCommon_float_or_param_type::domFloatRef ref = new(bytes) domCommon_float_or_param_type::domFloat;
+	return ref;
+}
+
+
+daeMetaElement *
+domCommon_float_or_param_type::domFloat::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float" );
+	_Meta->setStaticPointerAddress(&domCommon_float_or_param_type::domFloat::_Meta);
+	_Meta->registerConstructor(domCommon_float_or_param_type::domFloat::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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(daeInt bytes)
+{
+	domCommon_float_or_param_type::domParamRef ref = new(bytes) domCommon_float_or_param_type::domParam;
+	return ref;
+}
+
+
+daeMetaElement *
+domCommon_float_or_param_type::domParam::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "param" );
+	_Meta->setStaticPointerAddress(&domCommon_float_or_param_type::domParam::_Meta);
+	_Meta->registerConstructor(domCommon_float_or_param_type::domParam::create);
+
+
+	//	Add attribute: ref
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "ref" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domCommon_float_or_param_type::_Meta = NULL;
+daeMetaElement * domCommon_float_or_param_type::domFloat::_Meta = NULL;
+daeMetaElement * domCommon_float_or_param_type::domParam::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCommon_newparam_type.cpp

@@ -0,0 +1,249 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCommon_newparam_type.h>
+
+daeElementRef
+domCommon_newparam_type::create(daeInt bytes)
+{
+	domCommon_newparam_typeRef ref = new(bytes) domCommon_newparam_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domCommon_newparam_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "common_newparam_type" );
+	_Meta->setStaticPointerAddress(&domCommon_newparam_type::_Meta);
+	_Meta->registerConstructor(domCommon_newparam_type::create);
+
+	// Add elements: semantic, float, float2, float3, float4, surface, sampler2D
+    _Meta->appendElement(domCommon_newparam_type::domSemantic::registerElement(),daeOffsetOf(domCommon_newparam_type,elemSemantic));
+    _Meta->appendElement(domCommon_newparam_type::domFloat::registerElement(),daeOffsetOf(domCommon_newparam_type,elemFloat));
+    _Meta->appendElement(domCommon_newparam_type::domFloat2::registerElement(),daeOffsetOf(domCommon_newparam_type,elemFloat2));
+    _Meta->appendElement(domCommon_newparam_type::domFloat3::registerElement(),daeOffsetOf(domCommon_newparam_type,elemFloat3));
+    _Meta->appendElement(domCommon_newparam_type::domFloat4::registerElement(),daeOffsetOf(domCommon_newparam_type,elemFloat4));
+    _Meta->appendElement(domFx_surface_common::registerElement(),daeOffsetOf(domCommon_newparam_type,elemSurface),"surface"); 
+    _Meta->appendElement(domFx_sampler2D_common::registerElement(),daeOffsetOf(domCommon_newparam_type,elemSampler2D),"sampler2D"); 
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domCommon_newparam_type,_contents));
+
+
+	//	Add attribute: sid
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "sid" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domCommon_newparam_type::domSemanticRef ref = new(bytes) domCommon_newparam_type::domSemantic;
+	return ref;
+}
+
+
+daeMetaElement *
+domCommon_newparam_type::domSemantic::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "semantic" );
+	_Meta->setStaticPointerAddress(&domCommon_newparam_type::domSemantic::_Meta);
+	_Meta->registerConstructor(domCommon_newparam_type::domSemantic::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domCommon_newparam_type::domFloatRef ref = new(bytes) domCommon_newparam_type::domFloat;
+	return ref;
+}
+
+
+daeMetaElement *
+domCommon_newparam_type::domFloat::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float" );
+	_Meta->setStaticPointerAddress(&domCommon_newparam_type::domFloat::_Meta);
+	_Meta->registerConstructor(domCommon_newparam_type::domFloat::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domCommon_newparam_type::domFloat2Ref ref = new(bytes) domCommon_newparam_type::domFloat2;
+	return ref;
+}
+
+
+daeMetaElement *
+domCommon_newparam_type::domFloat2::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float2" );
+	_Meta->setStaticPointerAddress(&domCommon_newparam_type::domFloat2::_Meta);
+	_Meta->registerConstructor(domCommon_newparam_type::domFloat2::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domCommon_newparam_type::domFloat3Ref ref = new(bytes) domCommon_newparam_type::domFloat3;
+	return ref;
+}
+
+
+daeMetaElement *
+domCommon_newparam_type::domFloat3::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float3" );
+	_Meta->setStaticPointerAddress(&domCommon_newparam_type::domFloat3::_Meta);
+	_Meta->registerConstructor(domCommon_newparam_type::domFloat3::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domCommon_newparam_type::domFloat4Ref ref = new(bytes) domCommon_newparam_type::domFloat4;
+	return ref;
+}
+
+
+daeMetaElement *
+domCommon_newparam_type::domFloat4::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float4" );
+	_Meta->setStaticPointerAddress(&domCommon_newparam_type::domFloat4::_Meta);
+	_Meta->registerConstructor(domCommon_newparam_type::domFloat4::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domCommon_newparam_type::_Meta = NULL;
+daeMetaElement * domCommon_newparam_type::domSemantic::_Meta = NULL;
+daeMetaElement * domCommon_newparam_type::domFloat::_Meta = NULL;
+daeMetaElement * domCommon_newparam_type::domFloat2::_Meta = NULL;
+daeMetaElement * domCommon_newparam_type::domFloat3::_Meta = NULL;
+daeMetaElement * domCommon_newparam_type::domFloat4::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domConstants.cpp

@@ -0,0 +1,557 @@
+/*
+ * 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 <dom/domConstants.h>
+
+daeString COLLADA_VERSION = "1.4.0";
+daeString COLLADA_NAMESPACE = "http://www.collada.org/2005/11/COLLADASchema";
+
+daeString COMMON_PROFILE_INPUT_BINORMAL = "BINORMAL";
+daeString COMMON_PROFILE_INPUT_COLOR = "COLOR";
+daeString COMMON_PROFILE_INPUT_IMAGE = "IMAGE";
+daeString COMMON_PROFILE_INPUT_IN_TANGENT = "IN_TANGENT";
+daeString COMMON_PROFILE_INPUT_INPUT = "INPUT";
+daeString COMMON_PROFILE_INPUT_INTERPOLATION = "INTERPOLATION";
+daeString COMMON_PROFILE_INPUT_INV_BIND_MATRIX = "INV_BIND_MATRIX";
+daeString COMMON_PROFILE_INPUT_JOINT = "JOINT";
+daeString COMMON_PROFILE_INPUT_NORMAL = "NORMAL";
+daeString COMMON_PROFILE_INPUT_OUTPUT = "OUTPUT";
+daeString COMMON_PROFILE_INPUT_OUT_TANGENT = "OUT_TANGENT";
+daeString COMMON_PROFILE_INPUT_POSITION = "POSITION";
+daeString COMMON_PROFILE_INPUT_TANGENT = "TANGENT";
+daeString COMMON_PROFILE_INPUT_TEXCOORD = "TEXCOORD";
+daeString COMMON_PROFILE_INPUT_TEXTURE = "TEXTURE";
+daeString COMMON_PROFILE_INPUT_UV = "UV";
+daeString COMMON_PROFILE_INPUT_VERTEX = "VERTEX";
+daeString COMMON_PROFILE_INPUT_WEIGHT = "WEIGHT";
+
+daeString COMMON_PROFILE_PARAM_A = "A";
+daeString COMMON_PROFILE_PARAM_ANGLE = "ANGLE";
+daeString COMMON_PROFILE_PARAM_B = "B";
+daeString COMMON_PROFILE_PARAM_DOUBLE_SIDED = "DOUBLE_SIDED";
+daeString COMMON_PROFILE_PARAM_G = "G";
+daeString COMMON_PROFILE_PARAM_P = "P";
+daeString COMMON_PROFILE_PARAM_Q = "Q";
+daeString COMMON_PROFILE_PARAM_R = "R";
+daeString COMMON_PROFILE_PARAM_S = "S";
+daeString COMMON_PROFILE_PARAM_T = "T";
+daeString COMMON_PROFILE_PARAM_TIME = "TIME";
+daeString COMMON_PROFILE_PARAM_U = "U";
+daeString COMMON_PROFILE_PARAM_V = "V";
+daeString COMMON_PROFILE_PARAM_W = "W";
+daeString COMMON_PROFILE_PARAM_X = "X";
+daeString COMMON_PROFILE_PARAM_Y = "Y";
+daeString COMMON_PROFILE_PARAM_Z = "Z";
+
+daeString COLLADA_ELEMENT_INPUTGLOBAL = "InputGlobal";
+daeString COLLADA_ELEMENT_INPUTLOCAL = "InputLocal";
+daeString COLLADA_ELEMENT_INPUTLOCALOFFSET = "InputLocalOffset";
+daeString COLLADA_ELEMENT_INSTANCEWITHEXTRA = "InstanceWithExtra";
+daeString COLLADA_ELEMENT_TARGETABLEFLOAT = "TargetableFloat";
+daeString COLLADA_ELEMENT_TARGETABLEFLOAT3 = "TargetableFloat3";
+daeString COLLADA_ELEMENT_FX_SURFACE_COMMON = "fx_surface_common";
+daeString COLLADA_ELEMENT_INIT_FROM = "init_from";
+daeString COLLADA_ELEMENT_FORMAT = "format";
+daeString COLLADA_ELEMENT_SIZE = "size";
+daeString COLLADA_ELEMENT_VIEWPORT_RATIO = "viewport_ratio";
+daeString COLLADA_ELEMENT_MIP_LEVELS = "mip_levels";
+daeString COLLADA_ELEMENT_MIPMAP_GENERATE = "mipmap_generate";
+daeString COLLADA_ELEMENT_FX_SAMPLER1D_COMMON = "fx_sampler1D_common";
+daeString COLLADA_ELEMENT_SOURCE = "source";
+daeString COLLADA_ELEMENT_WRAP_S = "wrap_s";
+daeString COLLADA_ELEMENT_MINFILTER = "minfilter";
+daeString COLLADA_ELEMENT_MAGFILTER = "magfilter";
+daeString COLLADA_ELEMENT_MIPFILTER = "mipfilter";
+daeString COLLADA_ELEMENT_BORDER_COLOR = "border_color";
+daeString COLLADA_ELEMENT_MIPMAP_MAXLEVEL = "mipmap_maxlevel";
+daeString COLLADA_ELEMENT_MIPMAP_BIAS = "mipmap_bias";
+daeString COLLADA_ELEMENT_FX_SAMPLER2D_COMMON = "fx_sampler2D_common";
+daeString COLLADA_ELEMENT_WRAP_T = "wrap_t";
+daeString COLLADA_ELEMENT_FX_SAMPLER3D_COMMON = "fx_sampler3D_common";
+daeString COLLADA_ELEMENT_WRAP_P = "wrap_p";
+daeString COLLADA_ELEMENT_FX_SAMPLERCUBE_COMMON = "fx_samplerCUBE_common";
+daeString COLLADA_ELEMENT_FX_SAMPLERRECT_COMMON = "fx_samplerRECT_common";
+daeString COLLADA_ELEMENT_FX_SAMPLERDEPTH_COMMON = "fx_samplerDEPTH_common";
+daeString COLLADA_ELEMENT_FX_COLORTARGET_COMMON = "fx_colortarget_common";
+daeString COLLADA_ELEMENT_FX_DEPTHTARGET_COMMON = "fx_depthtarget_common";
+daeString COLLADA_ELEMENT_FX_STENCILTARGET_COMMON = "fx_stenciltarget_common";
+daeString COLLADA_ELEMENT_FX_CLEARCOLOR_COMMON = "fx_clearcolor_common";
+daeString COLLADA_ELEMENT_FX_CLEARDEPTH_COMMON = "fx_cleardepth_common";
+daeString COLLADA_ELEMENT_FX_CLEARSTENCIL_COMMON = "fx_clearstencil_common";
+daeString COLLADA_ELEMENT_FX_ANNOTATE_COMMON = "fx_annotate_common";
+daeString COLLADA_ELEMENT_FX_INCLUDE_COMMON = "fx_include_common";
+daeString COLLADA_ELEMENT_FX_NEWPARAM_COMMON = "fx_newparam_common";
+daeString COLLADA_ELEMENT_SEMANTIC = "semantic";
+daeString COLLADA_ELEMENT_MODIFIER = "modifier";
+daeString COLLADA_ELEMENT_FX_SETPARAM_COMMON = "fx_setparam_common";
+daeString COLLADA_ELEMENT_FX_CODE_PROFILE = "fx_code_profile";
+daeString COLLADA_ELEMENT_GL_SAMPLER1D = "gl_sampler1D";
+daeString COLLADA_ELEMENT_GL_SAMPLER2D = "gl_sampler2D";
+daeString COLLADA_ELEMENT_GL_SAMPLER3D = "gl_sampler3D";
+daeString COLLADA_ELEMENT_GL_SAMPLERCUBE = "gl_samplerCUBE";
+daeString COLLADA_ELEMENT_GL_SAMPLERRECT = "gl_samplerRECT";
+daeString COLLADA_ELEMENT_GL_SAMPLERDEPTH = "gl_samplerDEPTH";
+daeString COLLADA_ELEMENT_GLSL_NEWARRAY_TYPE = "glsl_newarray_type";
+daeString COLLADA_ELEMENT_GLSL_SETARRAY_TYPE = "glsl_setarray_type";
+daeString COLLADA_ELEMENT_GLSL_SURFACE_TYPE = "glsl_surface_type";
+daeString COLLADA_ELEMENT_GENERATOR = "generator";
+daeString COLLADA_ELEMENT_NAME = "name";
+daeString COLLADA_ELEMENT_GLSL_NEWPARAM = "glsl_newparam";
+daeString COLLADA_ELEMENT_GLSL_SETPARAM_SIMPLE = "glsl_setparam_simple";
+daeString COLLADA_ELEMENT_GLSL_SETPARAM = "glsl_setparam";
+daeString COLLADA_ELEMENT_COMMON_FLOAT_OR_PARAM_TYPE = "common_float_or_param_type";
+daeString COLLADA_ELEMENT_FLOAT = "float";
+daeString COLLADA_ELEMENT_PARAM = "param";
+daeString COLLADA_ELEMENT_COMMON_COLOR_OR_TEXTURE_TYPE = "common_color_or_texture_type";
+daeString COLLADA_ELEMENT_COLOR = "color";
+daeString COLLADA_ELEMENT_TEXTURE = "texture";
+daeString COLLADA_ELEMENT_COMMON_NEWPARAM_TYPE = "common_newparam_type";
+daeString COLLADA_ELEMENT_FLOAT2 = "float2";
+daeString COLLADA_ELEMENT_FLOAT3 = "float3";
+daeString COLLADA_ELEMENT_FLOAT4 = "float4";
+daeString COLLADA_ELEMENT_CG_SAMPLER1D = "cg_sampler1D";
+daeString COLLADA_ELEMENT_CG_SAMPLER2D = "cg_sampler2D";
+daeString COLLADA_ELEMENT_CG_SAMPLER3D = "cg_sampler3D";
+daeString COLLADA_ELEMENT_CG_SAMPLERCUBE = "cg_samplerCUBE";
+daeString COLLADA_ELEMENT_CG_SAMPLERRECT = "cg_samplerRECT";
+daeString COLLADA_ELEMENT_CG_SAMPLERDEPTH = "cg_samplerDEPTH";
+daeString COLLADA_ELEMENT_CG_CONNECT_PARAM = "cg_connect_param";
+daeString COLLADA_ELEMENT_CG_NEWARRAY_TYPE = "cg_newarray_type";
+daeString COLLADA_ELEMENT_CG_SETARRAY_TYPE = "cg_setarray_type";
+daeString COLLADA_ELEMENT_CG_SETUSER_TYPE = "cg_setuser_type";
+daeString COLLADA_ELEMENT_CG_SURFACE_TYPE = "cg_surface_type";
+daeString COLLADA_ELEMENT_CG_NEWPARAM = "cg_newparam";
+daeString COLLADA_ELEMENT_CG_SETPARAM_SIMPLE = "cg_setparam_simple";
+daeString COLLADA_ELEMENT_CG_SETPARAM = "cg_setparam";
+daeString COLLADA_ELEMENT_GLES_TEXTURE_CONSTANT_TYPE = "gles_texture_constant_type";
+daeString COLLADA_ELEMENT_GLES_TEXENV_COMMAND_TYPE = "gles_texenv_command_type";
+daeString COLLADA_ELEMENT_GLES_TEXCOMBINER_ARGUMENTRGB_TYPE = "gles_texcombiner_argumentRGB_type";
+daeString COLLADA_ELEMENT_GLES_TEXCOMBINER_ARGUMENTALPHA_TYPE = "gles_texcombiner_argumentAlpha_type";
+daeString COLLADA_ELEMENT_GLES_TEXCOMBINER_COMMANDRGB_TYPE = "gles_texcombiner_commandRGB_type";
+daeString COLLADA_ELEMENT_GLES_TEXCOMBINER_COMMANDALPHA_TYPE = "gles_texcombiner_commandAlpha_type";
+daeString COLLADA_ELEMENT_GLES_TEXCOMBINER_COMMAND_TYPE = "gles_texcombiner_command_type";
+daeString COLLADA_ELEMENT_GLES_TEXTURE_PIPELINE = "gles_texture_pipeline";
+daeString COLLADA_ELEMENT_GLES_TEXTURE_UNIT = "gles_texture_unit";
+daeString COLLADA_ELEMENT_SURFACE = "surface";
+daeString COLLADA_ELEMENT_SAMPLER_STATE = "sampler_state";
+daeString COLLADA_ELEMENT_TEXCOORD = "texcoord";
+daeString COLLADA_ELEMENT_GLES_SAMPLER_STATE = "gles_sampler_state";
+daeString COLLADA_ELEMENT_GLES_NEWPARAM = "gles_newparam";
+daeString COLLADA_ELEMENT_FX_ANNOTATE_TYPE_COMMON = "fx_annotate_type_common";
+daeString COLLADA_ELEMENT_BOOL = "bool";
+daeString COLLADA_ELEMENT_BOOL2 = "bool2";
+daeString COLLADA_ELEMENT_BOOL3 = "bool3";
+daeString COLLADA_ELEMENT_BOOL4 = "bool4";
+daeString COLLADA_ELEMENT_INT = "int";
+daeString COLLADA_ELEMENT_INT2 = "int2";
+daeString COLLADA_ELEMENT_INT3 = "int3";
+daeString COLLADA_ELEMENT_INT4 = "int4";
+daeString COLLADA_ELEMENT_FLOAT2X2 = "float2x2";
+daeString COLLADA_ELEMENT_FLOAT3X3 = "float3x3";
+daeString COLLADA_ELEMENT_FLOAT4X4 = "float4x4";
+daeString COLLADA_ELEMENT_STRING = "string";
+daeString COLLADA_ELEMENT_FX_BASIC_TYPE_COMMON = "fx_basic_type_common";
+daeString COLLADA_ELEMENT_FLOAT1X1 = "float1x1";
+daeString COLLADA_ELEMENT_FLOAT1X2 = "float1x2";
+daeString COLLADA_ELEMENT_FLOAT1X3 = "float1x3";
+daeString COLLADA_ELEMENT_FLOAT1X4 = "float1x4";
+daeString COLLADA_ELEMENT_FLOAT2X1 = "float2x1";
+daeString COLLADA_ELEMENT_FLOAT2X3 = "float2x3";
+daeString COLLADA_ELEMENT_FLOAT2X4 = "float2x4";
+daeString COLLADA_ELEMENT_FLOAT3X1 = "float3x1";
+daeString COLLADA_ELEMENT_FLOAT3X2 = "float3x2";
+daeString COLLADA_ELEMENT_FLOAT3X4 = "float3x4";
+daeString COLLADA_ELEMENT_FLOAT4X1 = "float4x1";
+daeString COLLADA_ELEMENT_FLOAT4X2 = "float4x2";
+daeString COLLADA_ELEMENT_FLOAT4X3 = "float4x3";
+daeString COLLADA_ELEMENT_ENUM = "enum";
+daeString COLLADA_ELEMENT_GL_PIPELINE_SETTINGS = "gl_pipeline_settings";
+daeString COLLADA_ELEMENT_ALPHA_FUNC = "alpha_func";
+daeString COLLADA_ELEMENT_FUNC = "func";
+daeString COLLADA_ELEMENT_VALUE = "value";
+daeString COLLADA_ELEMENT_BLEND_FUNC = "blend_func";
+daeString COLLADA_ELEMENT_SRC = "src";
+daeString COLLADA_ELEMENT_DEST = "dest";
+daeString COLLADA_ELEMENT_BLEND_FUNC_SEPARATE = "blend_func_separate";
+daeString COLLADA_ELEMENT_SRC_RGB = "src_rgb";
+daeString COLLADA_ELEMENT_DEST_RGB = "dest_rgb";
+daeString COLLADA_ELEMENT_SRC_ALPHA = "src_alpha";
+daeString COLLADA_ELEMENT_DEST_ALPHA = "dest_alpha";
+daeString COLLADA_ELEMENT_BLEND_EQUATION = "blend_equation";
+daeString COLLADA_ELEMENT_BLEND_EQUATION_SEPARATE = "blend_equation_separate";
+daeString COLLADA_ELEMENT_RGB = "rgb";
+daeString COLLADA_ELEMENT_ALPHA = "alpha";
+daeString COLLADA_ELEMENT_COLOR_MATERIAL = "color_material";
+daeString COLLADA_ELEMENT_FACE = "face";
+daeString COLLADA_ELEMENT_MODE = "mode";
+daeString COLLADA_ELEMENT_CULL_FACE = "cull_face";
+daeString COLLADA_ELEMENT_DEPTH_FUNC = "depth_func";
+daeString COLLADA_ELEMENT_FOG_MODE = "fog_mode";
+daeString COLLADA_ELEMENT_FOG_COORD_SRC = "fog_coord_src";
+daeString COLLADA_ELEMENT_FRONT_FACE = "front_face";
+daeString COLLADA_ELEMENT_LIGHT_MODEL_COLOR_CONTROL = "light_model_color_control";
+daeString COLLADA_ELEMENT_LOGIC_OP = "logic_op";
+daeString COLLADA_ELEMENT_POLYGON_MODE = "polygon_mode";
+daeString COLLADA_ELEMENT_SHADE_MODEL = "shade_model";
+daeString COLLADA_ELEMENT_STENCIL_FUNC = "stencil_func";
+daeString COLLADA_ELEMENT_REF = "ref";
+daeString COLLADA_ELEMENT_MASK = "mask";
+daeString COLLADA_ELEMENT_STENCIL_OP = "stencil_op";
+daeString COLLADA_ELEMENT_FAIL = "fail";
+daeString COLLADA_ELEMENT_ZFAIL = "zfail";
+daeString COLLADA_ELEMENT_ZPASS = "zpass";
+daeString COLLADA_ELEMENT_STENCIL_FUNC_SEPARATE = "stencil_func_separate";
+daeString COLLADA_ELEMENT_FRONT = "front";
+daeString COLLADA_ELEMENT_BACK = "back";
+daeString COLLADA_ELEMENT_STENCIL_OP_SEPARATE = "stencil_op_separate";
+daeString COLLADA_ELEMENT_STENCIL_MASK_SEPARATE = "stencil_mask_separate";
+daeString COLLADA_ELEMENT_LIGHT_ENABLE = "light_enable";
+daeString COLLADA_ELEMENT_LIGHT_AMBIENT = "light_ambient";
+daeString COLLADA_ELEMENT_LIGHT_DIFFUSE = "light_diffuse";
+daeString COLLADA_ELEMENT_LIGHT_SPECULAR = "light_specular";
+daeString COLLADA_ELEMENT_LIGHT_POSITION = "light_position";
+daeString COLLADA_ELEMENT_LIGHT_CONSTANT_ATTENUATION = "light_constant_attenuation";
+daeString COLLADA_ELEMENT_LIGHT_LINEAR_ATTENUATION = "light_linear_attenuation";
+daeString COLLADA_ELEMENT_LIGHT_QUADRATIC_ATTENUATION = "light_quadratic_attenuation";
+daeString COLLADA_ELEMENT_LIGHT_SPOT_CUTOFF = "light_spot_cutoff";
+daeString COLLADA_ELEMENT_LIGHT_SPOT_DIRECTION = "light_spot_direction";
+daeString COLLADA_ELEMENT_LIGHT_SPOT_EXPONENT = "light_spot_exponent";
+daeString COLLADA_ELEMENT_TEXTURE1D = "texture1D";
+daeString COLLADA_ELEMENT_TEXTURE2D = "texture2D";
+daeString COLLADA_ELEMENT_TEXTURE3D = "texture3D";
+daeString COLLADA_ELEMENT_TEXTURECUBE = "textureCUBE";
+daeString COLLADA_ELEMENT_TEXTURERECT = "textureRECT";
+daeString COLLADA_ELEMENT_TEXTUREDEPTH = "textureDEPTH";
+daeString COLLADA_ELEMENT_TEXTURE1D_ENABLE = "texture1D_enable";
+daeString COLLADA_ELEMENT_TEXTURE2D_ENABLE = "texture2D_enable";
+daeString COLLADA_ELEMENT_TEXTURE3D_ENABLE = "texture3D_enable";
+daeString COLLADA_ELEMENT_TEXTURECUBE_ENABLE = "textureCUBE_enable";
+daeString COLLADA_ELEMENT_TEXTURERECT_ENABLE = "textureRECT_enable";
+daeString COLLADA_ELEMENT_TEXTUREDEPTH_ENABLE = "textureDEPTH_enable";
+daeString COLLADA_ELEMENT_TEXTURE_ENV_COLOR = "texture_env_color";
+daeString COLLADA_ELEMENT_TEXTURE_ENV_MODE = "texture_env_mode";
+daeString COLLADA_ELEMENT_CLIP_PLANE = "clip_plane";
+daeString COLLADA_ELEMENT_CLIP_PLANE_ENABLE = "clip_plane_enable";
+daeString COLLADA_ELEMENT_BLEND_COLOR = "blend_color";
+daeString COLLADA_ELEMENT_CLEAR_COLOR = "clear_color";
+daeString COLLADA_ELEMENT_CLEAR_STENCIL = "clear_stencil";
+daeString COLLADA_ELEMENT_CLEAR_DEPTH = "clear_depth";
+daeString COLLADA_ELEMENT_COLOR_MASK = "color_mask";
+daeString COLLADA_ELEMENT_DEPTH_BOUNDS = "depth_bounds";
+daeString COLLADA_ELEMENT_DEPTH_MASK = "depth_mask";
+daeString COLLADA_ELEMENT_DEPTH_RANGE = "depth_range";
+daeString COLLADA_ELEMENT_FOG_DENSITY = "fog_density";
+daeString COLLADA_ELEMENT_FOG_START = "fog_start";
+daeString COLLADA_ELEMENT_FOG_END = "fog_end";
+daeString COLLADA_ELEMENT_FOG_COLOR = "fog_color";
+daeString COLLADA_ELEMENT_LIGHT_MODEL_AMBIENT = "light_model_ambient";
+daeString COLLADA_ELEMENT_LIGHTING_ENABLE = "lighting_enable";
+daeString COLLADA_ELEMENT_LINE_STIPPLE = "line_stipple";
+daeString COLLADA_ELEMENT_LINE_WIDTH = "line_width";
+daeString COLLADA_ELEMENT_MATERIAL_AMBIENT = "material_ambient";
+daeString COLLADA_ELEMENT_MATERIAL_DIFFUSE = "material_diffuse";
+daeString COLLADA_ELEMENT_MATERIAL_EMISSION = "material_emission";
+daeString COLLADA_ELEMENT_MATERIAL_SHININESS = "material_shininess";
+daeString COLLADA_ELEMENT_MATERIAL_SPECULAR = "material_specular";
+daeString COLLADA_ELEMENT_MODEL_VIEW_MATRIX = "model_view_matrix";
+daeString COLLADA_ELEMENT_POINT_DISTANCE_ATTENUATION = "point_distance_attenuation";
+daeString COLLADA_ELEMENT_POINT_FADE_THRESHOLD_SIZE = "point_fade_threshold_size";
+daeString COLLADA_ELEMENT_POINT_SIZE = "point_size";
+daeString COLLADA_ELEMENT_POINT_SIZE_MIN = "point_size_min";
+daeString COLLADA_ELEMENT_POINT_SIZE_MAX = "point_size_max";
+daeString COLLADA_ELEMENT_POLYGON_OFFSET = "polygon_offset";
+daeString COLLADA_ELEMENT_PROJECTION_MATRIX = "projection_matrix";
+daeString COLLADA_ELEMENT_SCISSOR = "scissor";
+daeString COLLADA_ELEMENT_STENCIL_MASK = "stencil_mask";
+daeString COLLADA_ELEMENT_ALPHA_TEST_ENABLE = "alpha_test_enable";
+daeString COLLADA_ELEMENT_AUTO_NORMAL_ENABLE = "auto_normal_enable";
+daeString COLLADA_ELEMENT_BLEND_ENABLE = "blend_enable";
+daeString COLLADA_ELEMENT_COLOR_LOGIC_OP_ENABLE = "color_logic_op_enable";
+daeString COLLADA_ELEMENT_CULL_FACE_ENABLE = "cull_face_enable";
+daeString COLLADA_ELEMENT_DEPTH_BOUNDS_ENABLE = "depth_bounds_enable";
+daeString COLLADA_ELEMENT_DEPTH_CLAMP_ENABLE = "depth_clamp_enable";
+daeString COLLADA_ELEMENT_DEPTH_TEST_ENABLE = "depth_test_enable";
+daeString COLLADA_ELEMENT_DITHER_ENABLE = "dither_enable";
+daeString COLLADA_ELEMENT_FOG_ENABLE = "fog_enable";
+daeString COLLADA_ELEMENT_LIGHT_MODEL_LOCAL_VIEWER_ENABLE = "light_model_local_viewer_enable";
+daeString COLLADA_ELEMENT_LIGHT_MODEL_TWO_SIDE_ENABLE = "light_model_two_side_enable";
+daeString COLLADA_ELEMENT_LINE_SMOOTH_ENABLE = "line_smooth_enable";
+daeString COLLADA_ELEMENT_LINE_STIPPLE_ENABLE = "line_stipple_enable";
+daeString COLLADA_ELEMENT_LOGIC_OP_ENABLE = "logic_op_enable";
+daeString COLLADA_ELEMENT_MULTISAMPLE_ENABLE = "multisample_enable";
+daeString COLLADA_ELEMENT_NORMALIZE_ENABLE = "normalize_enable";
+daeString COLLADA_ELEMENT_POINT_SMOOTH_ENABLE = "point_smooth_enable";
+daeString COLLADA_ELEMENT_POLYGON_OFFSET_FILL_ENABLE = "polygon_offset_fill_enable";
+daeString COLLADA_ELEMENT_POLYGON_OFFSET_LINE_ENABLE = "polygon_offset_line_enable";
+daeString COLLADA_ELEMENT_POLYGON_OFFSET_POINT_ENABLE = "polygon_offset_point_enable";
+daeString COLLADA_ELEMENT_POLYGON_SMOOTH_ENABLE = "polygon_smooth_enable";
+daeString COLLADA_ELEMENT_POLYGON_STIPPLE_ENABLE = "polygon_stipple_enable";
+daeString COLLADA_ELEMENT_RESCALE_NORMAL_ENABLE = "rescale_normal_enable";
+daeString COLLADA_ELEMENT_SAMPLE_ALPHA_TO_COVERAGE_ENABLE = "sample_alpha_to_coverage_enable";
+daeString COLLADA_ELEMENT_SAMPLE_ALPHA_TO_ONE_ENABLE = "sample_alpha_to_one_enable";
+daeString COLLADA_ELEMENT_SAMPLE_COVERAGE_ENABLE = "sample_coverage_enable";
+daeString COLLADA_ELEMENT_SCISSOR_TEST_ENABLE = "scissor_test_enable";
+daeString COLLADA_ELEMENT_STENCIL_TEST_ENABLE = "stencil_test_enable";
+daeString COLLADA_ELEMENT_GLSL_PARAM_TYPE = "glsl_param_type";
+daeString COLLADA_ELEMENT_CG_PARAM_TYPE = "cg_param_type";
+daeString COLLADA_ELEMENT_BOOL1 = "bool1";
+daeString COLLADA_ELEMENT_BOOL1X1 = "bool1x1";
+daeString COLLADA_ELEMENT_BOOL1X2 = "bool1x2";
+daeString COLLADA_ELEMENT_BOOL1X3 = "bool1x3";
+daeString COLLADA_ELEMENT_BOOL1X4 = "bool1x4";
+daeString COLLADA_ELEMENT_BOOL2X1 = "bool2x1";
+daeString COLLADA_ELEMENT_BOOL2X2 = "bool2x2";
+daeString COLLADA_ELEMENT_BOOL2X3 = "bool2x3";
+daeString COLLADA_ELEMENT_BOOL2X4 = "bool2x4";
+daeString COLLADA_ELEMENT_BOOL3X1 = "bool3x1";
+daeString COLLADA_ELEMENT_BOOL3X2 = "bool3x2";
+daeString COLLADA_ELEMENT_BOOL3X3 = "bool3x3";
+daeString COLLADA_ELEMENT_BOOL3X4 = "bool3x4";
+daeString COLLADA_ELEMENT_BOOL4X1 = "bool4x1";
+daeString COLLADA_ELEMENT_BOOL4X2 = "bool4x2";
+daeString COLLADA_ELEMENT_BOOL4X3 = "bool4x3";
+daeString COLLADA_ELEMENT_BOOL4X4 = "bool4x4";
+daeString COLLADA_ELEMENT_FLOAT1 = "float1";
+daeString COLLADA_ELEMENT_INT1 = "int1";
+daeString COLLADA_ELEMENT_INT1X1 = "int1x1";
+daeString COLLADA_ELEMENT_INT1X2 = "int1x2";
+daeString COLLADA_ELEMENT_INT1X3 = "int1x3";
+daeString COLLADA_ELEMENT_INT1X4 = "int1x4";
+daeString COLLADA_ELEMENT_INT2X1 = "int2x1";
+daeString COLLADA_ELEMENT_INT2X2 = "int2x2";
+daeString COLLADA_ELEMENT_INT2X3 = "int2x3";
+daeString COLLADA_ELEMENT_INT2X4 = "int2x4";
+daeString COLLADA_ELEMENT_INT3X1 = "int3x1";
+daeString COLLADA_ELEMENT_INT3X2 = "int3x2";
+daeString COLLADA_ELEMENT_INT3X3 = "int3x3";
+daeString COLLADA_ELEMENT_INT3X4 = "int3x4";
+daeString COLLADA_ELEMENT_INT4X1 = "int4x1";
+daeString COLLADA_ELEMENT_INT4X2 = "int4x2";
+daeString COLLADA_ELEMENT_INT4X3 = "int4x3";
+daeString COLLADA_ELEMENT_INT4X4 = "int4x4";
+daeString COLLADA_ELEMENT_HALF = "half";
+daeString COLLADA_ELEMENT_HALF1 = "half1";
+daeString COLLADA_ELEMENT_HALF2 = "half2";
+daeString COLLADA_ELEMENT_HALF3 = "half3";
+daeString COLLADA_ELEMENT_HALF4 = "half4";
+daeString COLLADA_ELEMENT_HALF1X1 = "half1x1";
+daeString COLLADA_ELEMENT_HALF1X2 = "half1x2";
+daeString COLLADA_ELEMENT_HALF1X3 = "half1x3";
+daeString COLLADA_ELEMENT_HALF1X4 = "half1x4";
+daeString COLLADA_ELEMENT_HALF2X1 = "half2x1";
+daeString COLLADA_ELEMENT_HALF2X2 = "half2x2";
+daeString COLLADA_ELEMENT_HALF2X3 = "half2x3";
+daeString COLLADA_ELEMENT_HALF2X4 = "half2x4";
+daeString COLLADA_ELEMENT_HALF3X1 = "half3x1";
+daeString COLLADA_ELEMENT_HALF3X2 = "half3x2";
+daeString COLLADA_ELEMENT_HALF3X3 = "half3x3";
+daeString COLLADA_ELEMENT_HALF3X4 = "half3x4";
+daeString COLLADA_ELEMENT_HALF4X1 = "half4x1";
+daeString COLLADA_ELEMENT_HALF4X2 = "half4x2";
+daeString COLLADA_ELEMENT_HALF4X3 = "half4x3";
+daeString COLLADA_ELEMENT_HALF4X4 = "half4x4";
+daeString COLLADA_ELEMENT_FIXED = "fixed";
+daeString COLLADA_ELEMENT_FIXED1 = "fixed1";
+daeString COLLADA_ELEMENT_FIXED2 = "fixed2";
+daeString COLLADA_ELEMENT_FIXED3 = "fixed3";
+daeString COLLADA_ELEMENT_FIXED4 = "fixed4";
+daeString COLLADA_ELEMENT_FIXED1X1 = "fixed1x1";
+daeString COLLADA_ELEMENT_FIXED1X2 = "fixed1x2";
+daeString COLLADA_ELEMENT_FIXED1X3 = "fixed1x3";
+daeString COLLADA_ELEMENT_FIXED1X4 = "fixed1x4";
+daeString COLLADA_ELEMENT_FIXED2X1 = "fixed2x1";
+daeString COLLADA_ELEMENT_FIXED2X2 = "fixed2x2";
+daeString COLLADA_ELEMENT_FIXED2X3 = "fixed2x3";
+daeString COLLADA_ELEMENT_FIXED2X4 = "fixed2x4";
+daeString COLLADA_ELEMENT_FIXED3X1 = "fixed3x1";
+daeString COLLADA_ELEMENT_FIXED3X2 = "fixed3x2";
+daeString COLLADA_ELEMENT_FIXED3X3 = "fixed3x3";
+daeString COLLADA_ELEMENT_FIXED3X4 = "fixed3x4";
+daeString COLLADA_ELEMENT_FIXED4X1 = "fixed4x1";
+daeString COLLADA_ELEMENT_FIXED4X2 = "fixed4x2";
+daeString COLLADA_ELEMENT_FIXED4X3 = "fixed4x3";
+daeString COLLADA_ELEMENT_FIXED4X4 = "fixed4x4";
+daeString COLLADA_ELEMENT_GLES_PIPELINE_SETTINGS = "gles_pipeline_settings";
+daeString COLLADA_ELEMENT_TEXTURE_PIPELINE = "texture_pipeline";
+daeString COLLADA_ELEMENT_LIGHT_LINEAR_ATTENUTATION = "light_linear_attenutation";
+daeString COLLADA_ELEMENT_COLOR_MATERIAL_ENABLE = "color_material_enable";
+daeString COLLADA_ELEMENT_TEXTURE_PIPELINE_ENABLE = "texture_pipeline_enable";
+daeString COLLADA_ELEMENT_GLES_BASIC_TYPE_COMMON = "gles_basic_type_common";
+daeString COLLADA_ELEMENT_COLLADA = "COLLADA";
+daeString COLLADA_ELEMENT_SCENE = "scene";
+daeString COLLADA_ELEMENT_IDREF_ARRAY = "IDREF_array";
+daeString COLLADA_ELEMENT_NAME_ARRAY = "Name_array";
+daeString COLLADA_ELEMENT_BOOL_ARRAY = "bool_array";
+daeString COLLADA_ELEMENT_FLOAT_ARRAY = "float_array";
+daeString COLLADA_ELEMENT_INT_ARRAY = "int_array";
+daeString COLLADA_ELEMENT_ACCESSOR = "accessor";
+daeString COLLADA_ELEMENT_TECHNIQUE_COMMON = "technique_common";
+daeString COLLADA_ELEMENT_GEOMETRY = "geometry";
+daeString COLLADA_ELEMENT_MESH = "mesh";
+daeString COLLADA_ELEMENT_SPLINE = "spline";
+daeString COLLADA_ELEMENT_CONTROL_VERTICES = "control_vertices";
+daeString COLLADA_ELEMENT_P = "p";
+daeString COLLADA_ELEMENT_LINES = "lines";
+daeString COLLADA_ELEMENT_LINESTRIPS = "linestrips";
+daeString COLLADA_ELEMENT_POLYGONS = "polygons";
+daeString COLLADA_ELEMENT_PH = "ph";
+daeString COLLADA_ELEMENT_H = "h";
+daeString COLLADA_ELEMENT_POLYLIST = "polylist";
+daeString COLLADA_ELEMENT_VCOUNT = "vcount";
+daeString COLLADA_ELEMENT_TRIANGLES = "triangles";
+daeString COLLADA_ELEMENT_TRIFANS = "trifans";
+daeString COLLADA_ELEMENT_TRISTRIPS = "tristrips";
+daeString COLLADA_ELEMENT_VERTICES = "vertices";
+daeString COLLADA_ELEMENT_LOOKAT = "lookat";
+daeString COLLADA_ELEMENT_MATRIX = "matrix";
+daeString COLLADA_ELEMENT_ROTATE = "rotate";
+daeString COLLADA_ELEMENT_SCALE = "scale";
+daeString COLLADA_ELEMENT_SKEW = "skew";
+daeString COLLADA_ELEMENT_TRANSLATE = "translate";
+daeString COLLADA_ELEMENT_IMAGE = "image";
+daeString COLLADA_ELEMENT_DATA = "data";
+daeString COLLADA_ELEMENT_LIGHT = "light";
+daeString COLLADA_ELEMENT_AMBIENT = "ambient";
+daeString COLLADA_ELEMENT_DIRECTIONAL = "directional";
+daeString COLLADA_ELEMENT_POINT = "point";
+daeString COLLADA_ELEMENT_SPOT = "spot";
+daeString COLLADA_ELEMENT_MATERIAL = "material";
+daeString COLLADA_ELEMENT_CAMERA = "camera";
+daeString COLLADA_ELEMENT_OPTICS = "optics";
+daeString COLLADA_ELEMENT_ORTHOGRAPHIC = "orthographic";
+daeString COLLADA_ELEMENT_PERSPECTIVE = "perspective";
+daeString COLLADA_ELEMENT_IMAGER = "imager";
+daeString COLLADA_ELEMENT_ANIMATION = "animation";
+daeString COLLADA_ELEMENT_ANIMATION_CLIP = "animation_clip";
+daeString COLLADA_ELEMENT_CHANNEL = "channel";
+daeString COLLADA_ELEMENT_SAMPLER = "sampler";
+daeString COLLADA_ELEMENT_CONTROLLER = "controller";
+daeString COLLADA_ELEMENT_SKIN = "skin";
+daeString COLLADA_ELEMENT_BIND_SHAPE_MATRIX = "bind_shape_matrix";
+daeString COLLADA_ELEMENT_JOINTS = "joints";
+daeString COLLADA_ELEMENT_VERTEX_WEIGHTS = "vertex_weights";
+daeString COLLADA_ELEMENT_V = "v";
+daeString COLLADA_ELEMENT_MORPH = "morph";
+daeString COLLADA_ELEMENT_TARGETS = "targets";
+daeString COLLADA_ELEMENT_ASSET = "asset";
+daeString COLLADA_ELEMENT_CONTRIBUTOR = "contributor";
+daeString COLLADA_ELEMENT_AUTHOR = "author";
+daeString COLLADA_ELEMENT_AUTHORING_TOOL = "authoring_tool";
+daeString COLLADA_ELEMENT_COMMENTS = "comments";
+daeString COLLADA_ELEMENT_COPYRIGHT = "copyright";
+daeString COLLADA_ELEMENT_SOURCE_DATA = "source_data";
+daeString COLLADA_ELEMENT_CREATED = "created";
+daeString COLLADA_ELEMENT_KEYWORDS = "keywords";
+daeString COLLADA_ELEMENT_MODIFIED = "modified";
+daeString COLLADA_ELEMENT_REVISION = "revision";
+daeString COLLADA_ELEMENT_SUBJECT = "subject";
+daeString COLLADA_ELEMENT_TITLE = "title";
+daeString COLLADA_ELEMENT_UNIT = "unit";
+daeString COLLADA_ELEMENT_UP_AXIS = "up_axis";
+daeString COLLADA_ELEMENT_EXTRA = "extra";
+daeString COLLADA_ELEMENT_TECHNIQUE = "technique";
+daeString COLLADA_ELEMENT_NODE = "node";
+daeString COLLADA_ELEMENT_VISUAL_SCENE = "visual_scene";
+daeString COLLADA_ELEMENT_EVALUATE_SCENE = "evaluate_scene";
+daeString COLLADA_ELEMENT_RENDER = "render";
+daeString COLLADA_ELEMENT_LAYER = "layer";
+daeString COLLADA_ELEMENT_BIND_MATERIAL = "bind_material";
+daeString COLLADA_ELEMENT_INSTANCE_CAMERA = "instance_camera";
+daeString COLLADA_ELEMENT_INSTANCE_CONTROLLER = "instance_controller";
+daeString COLLADA_ELEMENT_SKELETON = "skeleton";
+daeString COLLADA_ELEMENT_INSTANCE_EFFECT = "instance_effect";
+daeString COLLADA_ELEMENT_TECHNIQUE_HINT = "technique_hint";
+daeString COLLADA_ELEMENT_SETPARAM = "setparam";
+daeString COLLADA_ELEMENT_INSTANCE_FORCE_FIELD = "instance_force_field";
+daeString COLLADA_ELEMENT_INSTANCE_GEOMETRY = "instance_geometry";
+daeString COLLADA_ELEMENT_INSTANCE_LIGHT = "instance_light";
+daeString COLLADA_ELEMENT_INSTANCE_MATERIAL = "instance_material";
+daeString COLLADA_ELEMENT_BIND = "bind";
+daeString COLLADA_ELEMENT_INSTANCE_NODE = "instance_node";
+daeString COLLADA_ELEMENT_INSTANCE_PHYSICS_MATERIAL = "instance_physics_material";
+daeString COLLADA_ELEMENT_INSTANCE_PHYSICS_MODEL = "instance_physics_model";
+daeString COLLADA_ELEMENT_INSTANCE_RIGID_BODY = "instance_rigid_body";
+daeString COLLADA_ELEMENT_ANGULAR_VELOCITY = "angular_velocity";
+daeString COLLADA_ELEMENT_VELOCITY = "velocity";
+daeString COLLADA_ELEMENT_DYNAMIC = "dynamic";
+daeString COLLADA_ELEMENT_MASS_FRAME = "mass_frame";
+daeString COLLADA_ELEMENT_SHAPE = "shape";
+daeString COLLADA_ELEMENT_HOLLOW = "hollow";
+daeString COLLADA_ELEMENT_INSTANCE_RIGID_CONSTRAINT = "instance_rigid_constraint";
+daeString COLLADA_ELEMENT_LIBRARY_ANIMATIONS = "library_animations";
+daeString COLLADA_ELEMENT_LIBRARY_ANIMATION_CLIPS = "library_animation_clips";
+daeString COLLADA_ELEMENT_LIBRARY_CAMERAS = "library_cameras";
+daeString COLLADA_ELEMENT_LIBRARY_CONTROLLERS = "library_controllers";
+daeString COLLADA_ELEMENT_LIBRARY_GEOMETRIES = "library_geometries";
+daeString COLLADA_ELEMENT_LIBRARY_EFFECTS = "library_effects";
+daeString COLLADA_ELEMENT_LIBRARY_FORCE_FIELDS = "library_force_fields";
+daeString COLLADA_ELEMENT_LIBRARY_IMAGES = "library_images";
+daeString COLLADA_ELEMENT_LIBRARY_LIGHTS = "library_lights";
+daeString COLLADA_ELEMENT_LIBRARY_MATERIALS = "library_materials";
+daeString COLLADA_ELEMENT_LIBRARY_NODES = "library_nodes";
+daeString COLLADA_ELEMENT_LIBRARY_PHYSICS_MATERIALS = "library_physics_materials";
+daeString COLLADA_ELEMENT_LIBRARY_PHYSICS_MODELS = "library_physics_models";
+daeString COLLADA_ELEMENT_LIBRARY_PHYSICS_SCENES = "library_physics_scenes";
+daeString COLLADA_ELEMENT_LIBRARY_VISUAL_SCENES = "library_visual_scenes";
+daeString COLLADA_ELEMENT_FX_PROFILE_ABSTRACT = "fx_profile_abstract";
+daeString COLLADA_ELEMENT_EFFECT = "effect";
+daeString COLLADA_ELEMENT_GL_HOOK_ABSTRACT = "gl_hook_abstract";
+daeString COLLADA_ELEMENT_PROFILE_GLSL = "profile_GLSL";
+daeString COLLADA_ELEMENT_PASS = "pass";
+daeString COLLADA_ELEMENT_DRAW = "draw";
+daeString COLLADA_ELEMENT_SHADER = "shader";
+daeString COLLADA_ELEMENT_COMPILER_TARGET = "compiler_target";
+daeString COLLADA_ELEMENT_COMPILER_OPTIONS = "compiler_options";
+daeString COLLADA_ELEMENT_PROFILE_COMMON = "profile_COMMON";
+daeString COLLADA_ELEMENT_CONSTANT = "constant";
+daeString COLLADA_ELEMENT_LAMBERT = "lambert";
+daeString COLLADA_ELEMENT_PHONG = "phong";
+daeString COLLADA_ELEMENT_BLINN = "blinn";
+daeString COLLADA_ELEMENT_PROFILE_CG = "profile_CG";
+daeString COLLADA_ELEMENT_PROFILE_GLES = "profile_GLES";
+daeString COLLADA_ELEMENT_COLOR_TARGET = "color_target";
+daeString COLLADA_ELEMENT_DEPTH_TARGET = "depth_target";
+daeString COLLADA_ELEMENT_STENCIL_TARGET = "stencil_target";
+daeString COLLADA_ELEMENT_COLOR_CLEAR = "color_clear";
+daeString COLLADA_ELEMENT_DEPTH_CLEAR = "depth_clear";
+daeString COLLADA_ELEMENT_STENCIL_CLEAR = "stencil_clear";
+daeString COLLADA_ELEMENT_BOX = "box";
+daeString COLLADA_ELEMENT_HALF_EXTENTS = "half_extents";
+daeString COLLADA_ELEMENT_PLANE = "plane";
+daeString COLLADA_ELEMENT_EQUATION = "equation";
+daeString COLLADA_ELEMENT_SPHERE = "sphere";
+daeString COLLADA_ELEMENT_RADIUS = "radius";
+daeString COLLADA_ELEMENT_ELLIPSOID = "ellipsoid";
+daeString COLLADA_ELEMENT_CYLINDER = "cylinder";
+daeString COLLADA_ELEMENT_HEIGHT = "height";
+daeString COLLADA_ELEMENT_TAPERED_CYLINDER = "tapered_cylinder";
+daeString COLLADA_ELEMENT_RADIUS1 = "radius1";
+daeString COLLADA_ELEMENT_RADIUS2 = "radius2";
+daeString COLLADA_ELEMENT_CAPSULE = "capsule";
+daeString COLLADA_ELEMENT_TAPERED_CAPSULE = "tapered_capsule";
+daeString COLLADA_ELEMENT_CONVEX_MESH = "convex_mesh";
+daeString COLLADA_ELEMENT_FORCE_FIELD = "force_field";
+daeString COLLADA_ELEMENT_PHYSICS_MATERIAL = "physics_material";
+daeString COLLADA_ELEMENT_PHYSICS_SCENE = "physics_scene";
+daeString COLLADA_ELEMENT_RIGID_BODY = "rigid_body";
+daeString COLLADA_ELEMENT_RIGID_CONSTRAINT = "rigid_constraint";
+daeString COLLADA_ELEMENT_REF_ATTACHMENT = "ref_attachment";
+daeString COLLADA_ELEMENT_ATTACHMENT = "attachment";
+daeString COLLADA_ELEMENT_ENABLED = "enabled";
+daeString COLLADA_ELEMENT_INTERPENETRATE = "interpenetrate";
+daeString COLLADA_ELEMENT_LIMITS = "limits";
+daeString COLLADA_ELEMENT_SWING_CONE_AND_TWIST = "swing_cone_and_twist";
+daeString COLLADA_ELEMENT_LINEAR = "linear";
+daeString COLLADA_ELEMENT_SPRING = "spring";
+daeString COLLADA_ELEMENT_ANGULAR = "angular";
+daeString COLLADA_ELEMENT_PHYSICS_MODEL = "physics_model";

Extras/COLLADA_DOM/src/1.4/dom/domController.cpp

@@ -0,0 +1,76 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domController.h>
+
+daeElementRef
+domController::create(daeInt bytes)
+{
+	domControllerRef ref = new(bytes) domController;
+	return ref;
+}
+
+
+daeMetaElement *
+domController::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "controller" );
+	_Meta->setStaticPointerAddress(&domController::_Meta);
+	_Meta->registerConstructor(domController::create);
+
+	// Add elements: asset, skin, morph, extra
+    _Meta->appendElement(domAsset::registerElement(),daeOffsetOf(domController,elemAsset));
+    _Meta->appendElement(domSkin::registerElement(),daeOffsetOf(domController,elemSkin));
+    _Meta->appendElement(domMorph::registerElement(),daeOffsetOf(domController,elemMorph));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domController,elemExtra_array));
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domController,_contents));
+
+
+	//	Add attribute: id
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "id" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("xsNCName"));
+		ma->setOffset( daeOffsetOf( domController , attrName ));
+		ma->setContainer( _Meta );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domController));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domController::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domConvex_mesh.cpp

@@ -0,0 +1,72 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domConvex_mesh.h>
+
+daeElementRef
+domConvex_mesh::create(daeInt bytes)
+{
+	domConvex_meshRef ref = new(bytes) domConvex_mesh;
+	ref->attrConvex_hull_of.setContainer( (domConvex_mesh*)ref );
+	return ref;
+}
+
+
+daeMetaElement *
+domConvex_mesh::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "convex_mesh" );
+	_Meta->setStaticPointerAddress(&domConvex_mesh::_Meta);
+	_Meta->registerConstructor(domConvex_mesh::create);
+
+	// Add elements: source, vertices, lines, linestrips, polygons, polylist, triangles, trifans, tristrips, extra
+    _Meta->appendArrayElement(domSource::registerElement(),daeOffsetOf(domConvex_mesh,elemSource_array));
+    _Meta->appendElement(domVertices::registerElement(),daeOffsetOf(domConvex_mesh,elemVertices));
+    _Meta->appendArrayElement(domLines::registerElement(),daeOffsetOf(domConvex_mesh,elemLines_array));
+    _Meta->appendArrayElement(domLinestrips::registerElement(),daeOffsetOf(domConvex_mesh,elemLinestrips_array));
+    _Meta->appendArrayElement(domPolygons::registerElement(),daeOffsetOf(domConvex_mesh,elemPolygons_array));
+    _Meta->appendArrayElement(domPolylist::registerElement(),daeOffsetOf(domConvex_mesh,elemPolylist_array));
+    _Meta->appendArrayElement(domTriangles::registerElement(),daeOffsetOf(domConvex_mesh,elemTriangles_array));
+    _Meta->appendArrayElement(domTrifans::registerElement(),daeOffsetOf(domConvex_mesh,elemTrifans_array));
+    _Meta->appendArrayElement(domTristrips::registerElement(),daeOffsetOf(domConvex_mesh,elemTristrips_array));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domConvex_mesh,elemExtra_array));
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domConvex_mesh,_contents));
+
+
+	//	Add attribute: convex_hull_of
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "convex_hull_of" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domConvex_mesh::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domCylinder.cpp

@@ -0,0 +1,122 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domCylinder.h>
+
+daeElementRef
+domCylinder::create(daeInt bytes)
+{
+	domCylinderRef ref = new(bytes) domCylinder;
+	return ref;
+}
+
+
+daeMetaElement *
+domCylinder::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "cylinder" );
+	_Meta->setStaticPointerAddress(&domCylinder::_Meta);
+	_Meta->registerConstructor(domCylinder::create);
+
+	// Add elements: height, radius, extra
+    _Meta->appendElement(domCylinder::domHeight::registerElement(),daeOffsetOf(domCylinder,elemHeight));
+    _Meta->appendElement(domCylinder::domRadius::registerElement(),daeOffsetOf(domCylinder,elemRadius));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domCylinder,elemExtra_array));
+	
+	
+	_Meta->setElementSize(sizeof(domCylinder));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domCylinder::domHeight::create(daeInt bytes)
+{
+	domCylinder::domHeightRef ref = new(bytes) domCylinder::domHeight;
+	return ref;
+}
+
+
+daeMetaElement *
+domCylinder::domHeight::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "height" );
+	_Meta->setStaticPointerAddress(&domCylinder::domHeight::_Meta);
+	_Meta->registerConstructor(domCylinder::domHeight::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domCylinder::domRadiusRef ref = new(bytes) domCylinder::domRadius;
+	return ref;
+}
+
+
+daeMetaElement *
+domCylinder::domRadius::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "radius" );
+	_Meta->setStaticPointerAddress(&domCylinder::domRadius::_Meta);
+	_Meta->registerConstructor(domCylinder::domRadius::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::get("Float2"));
+		ma->setOffset( daeOffsetOf( domCylinder::domRadius , _value ));
+		ma->setContainer( _Meta );
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domCylinder::domRadius));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domCylinder::_Meta = NULL;
+daeMetaElement * domCylinder::domHeight::_Meta = NULL;
+daeMetaElement * domCylinder::domRadius::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domEffect.cpp

@@ -0,0 +1,87 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domEffect.h>
+
+daeElementRef
+domEffect::create(daeInt bytes)
+{
+	domEffectRef ref = new(bytes) domEffect;
+	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()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "effect" );
+	_Meta->setStaticPointerAddress(&domEffect::_Meta);
+	_Meta->registerConstructor(domEffect::create);
+
+	// Add elements: asset, annotate, image, newparam, fx_profile_abstract, extra
+    _Meta->appendElement(domAsset::registerElement(),daeOffsetOf(domEffect,elemAsset));
+    _Meta->appendArrayElement(domFx_annotate_common::registerElement(),daeOffsetOf(domEffect,elemAnnotate_array),"annotate"); 
+    _Meta->appendArrayElement(domImage::registerElement(),daeOffsetOf(domEffect,elemImage_array));
+    _Meta->appendArrayElement(domFx_newparam_common::registerElement(),daeOffsetOf(domEffect,elemNewparam_array),"newparam"); 
+    _Meta->appendArrayElement(domFx_profile_abstract::registerElement(),daeOffsetOf(domEffect,elemFx_profile_abstract_array));
+    _Meta->appendArrayElement(domProfile_GLSL::registerElement(),daeOffsetOf(domEffect,elemFx_profile_abstract_array));
+    _Meta->appendArrayElement(domProfile_COMMON::registerElement(),daeOffsetOf(domEffect,elemFx_profile_abstract_array));
+    _Meta->appendArrayElement(domProfile_CG::registerElement(),daeOffsetOf(domEffect,elemFx_profile_abstract_array));
+    _Meta->appendArrayElement(domProfile_GLES::registerElement(),daeOffsetOf(domEffect,elemFx_profile_abstract_array));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domEffect,elemExtra_array));
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domEffect,_contents));
+
+
+	//	Add attribute: id
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "id" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("xsNCName"));
+		ma->setOffset( daeOffsetOf( domEffect , attrName ));
+		ma->setContainer( _Meta );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domEffect));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domEffect::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domEllipsoid.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/daeDom.h>
+#include <dom/domEllipsoid.h>
+
+daeElementRef
+domEllipsoid::create(daeInt bytes)
+{
+	domEllipsoidRef ref = new(bytes) domEllipsoid;
+	return ref;
+}
+
+
+daeMetaElement *
+domEllipsoid::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "ellipsoid" );
+	_Meta->setStaticPointerAddress(&domEllipsoid::_Meta);
+	_Meta->registerConstructor(domEllipsoid::create);
+
+	// Add elements: size
+    _Meta->appendElement(domEllipsoid::domSize::registerElement(),daeOffsetOf(domEllipsoid,elemSize));
+	
+	
+	_Meta->setElementSize(sizeof(domEllipsoid));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domEllipsoid::domSize::create(daeInt bytes)
+{
+	domEllipsoid::domSizeRef ref = new(bytes) domEllipsoid::domSize;
+	return ref;
+}
+
+
+daeMetaElement *
+domEllipsoid::domSize::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "size" );
+	_Meta->setStaticPointerAddress(&domEllipsoid::domSize::_Meta);
+	_Meta->registerConstructor(domEllipsoid::domSize::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::get("Float3"));
+		ma->setOffset( daeOffsetOf( domEllipsoid::domSize , _value ));
+		ma->setContainer( _Meta );
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domEllipsoid::domSize));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domEllipsoid::_Meta = NULL;
+daeMetaElement * domEllipsoid::domSize::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domExtra.cpp

@@ -0,0 +1,82 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domExtra.h>
+
+daeElementRef
+domExtra::create(daeInt bytes)
+{
+	domExtraRef ref = new(bytes) domExtra;
+	return ref;
+}
+
+
+daeMetaElement *
+domExtra::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "extra" );
+	_Meta->setStaticPointerAddress(&domExtra::_Meta);
+	_Meta->registerConstructor(domExtra::create);
+
+	// Add elements: asset, technique
+    _Meta->appendElement(domAsset::registerElement(),daeOffsetOf(domExtra,elemAsset));
+    _Meta->appendArrayElement(domTechnique::registerElement(),daeOffsetOf(domExtra,elemTechnique_array));
+
+	//	Add attribute: id
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "id" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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( daeAtomicType::get("xsNMTOKEN"));
+		ma->setOffset( daeOffsetOf( domExtra , attrType ));
+		ma->setContainer( _Meta );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domExtra));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domExtra::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFloat_array.cpp

@@ -0,0 +1,113 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFloat_array.h>
+
+daeElementRef
+domFloat_array::create(daeInt bytes)
+{
+	domFloat_arrayRef ref = new(bytes) domFloat_array;
+	return ref;
+}
+
+
+daeMetaElement *
+domFloat_array::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float_array" );
+	_Meta->setStaticPointerAddress(&domFloat_array::_Meta);
+	_Meta->registerConstructor(domFloat_array::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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( daeAtomicType::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( daeAtomicType::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( daeAtomicType::get("xsShort"));
+		ma->setOffset( daeOffsetOf( domFloat_array , attrDigits ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "6");
+	
+		_Meta->appendAttribute(ma);
+	}
+
+	//	Add attribute: magnitude
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "magnitude" );
+		ma->setType( daeAtomicType::get("xsShort"));
+		ma->setOffset( daeOffsetOf( domFloat_array , attrMagnitude ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "38");
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domFloat_array));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domFloat_array::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domForce_field.cpp

@@ -0,0 +1,72 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domForce_field.h>
+
+daeElementRef
+domForce_field::create(daeInt bytes)
+{
+	domForce_fieldRef ref = new(bytes) domForce_field;
+	return ref;
+}
+
+
+daeMetaElement *
+domForce_field::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "force_field" );
+	_Meta->setStaticPointerAddress(&domForce_field::_Meta);
+	_Meta->registerConstructor(domForce_field::create);
+
+	// Add elements: asset, technique, extra
+    _Meta->appendElement(domAsset::registerElement(),daeOffsetOf(domForce_field,elemAsset));
+    _Meta->appendArrayElement(domTechnique::registerElement(),daeOffsetOf(domForce_field,elemTechnique_array));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domForce_field,elemExtra_array));
+
+	//	Add attribute: id
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "id" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("xsNCName"));
+		ma->setOffset( daeOffsetOf( domForce_field , attrName ));
+		ma->setContainer( _Meta );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domForce_field));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domForce_field::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_annotate_common.cpp

@@ -0,0 +1,76 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_annotate_common.h>
+
+daeElementRef
+domFx_annotate_common::create(daeInt bytes)
+{
+	domFx_annotate_commonRef ref = new(bytes) domFx_annotate_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_annotate_common" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_common::_Meta);
+	_Meta->registerConstructor(domFx_annotate_common::create);
+
+	// Add elements: fx_annotate_type_common
+    _Meta->appendElement(domFx_annotate_type_common::registerElement(),daeOffsetOf(domFx_annotate_common,elemFx_annotate_type_common));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "string", _Meta->getMetaElements()[0]);
+
+	//	Add attribute: name
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "name" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domFx_annotate_common::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_annotate_type_common.cpp

@@ -0,0 +1,643 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_annotate_type_common.h>
+
+daeElementRef
+domFx_annotate_type_common::create(daeInt bytes)
+{
+	domFx_annotate_type_commonRef ref = new(bytes) domFx_annotate_type_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_annotate_type_common" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::create);
+
+	_Meta->setIsTransparent( true );
+	// Add elements: bool, bool2, bool3, bool4, int, int2, int3, int4, float, float2, float3, float4, float2x2, float3x3, float4x4, string
+    _Meta->appendElement(domFx_annotate_type_common::domBool::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemBool));
+    _Meta->appendElement(domFx_annotate_type_common::domBool2::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemBool2));
+    _Meta->appendElement(domFx_annotate_type_common::domBool3::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemBool3));
+    _Meta->appendElement(domFx_annotate_type_common::domBool4::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemBool4));
+    _Meta->appendElement(domFx_annotate_type_common::domInt::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemInt));
+    _Meta->appendElement(domFx_annotate_type_common::domInt2::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemInt2));
+    _Meta->appendElement(domFx_annotate_type_common::domInt3::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemInt3));
+    _Meta->appendElement(domFx_annotate_type_common::domInt4::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemInt4));
+    _Meta->appendElement(domFx_annotate_type_common::domFloat::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemFloat));
+    _Meta->appendElement(domFx_annotate_type_common::domFloat2::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemFloat2));
+    _Meta->appendElement(domFx_annotate_type_common::domFloat3::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemFloat3));
+    _Meta->appendElement(domFx_annotate_type_common::domFloat4::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemFloat4));
+    _Meta->appendElement(domFx_annotate_type_common::domFloat2x2::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemFloat2x2));
+    _Meta->appendElement(domFx_annotate_type_common::domFloat3x3::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemFloat3x3));
+    _Meta->appendElement(domFx_annotate_type_common::domFloat4x4::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemFloat4x4));
+    _Meta->appendElement(domFx_annotate_type_common::domString::registerElement(),daeOffsetOf(domFx_annotate_type_common,elemString));
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domFx_annotate_type_common,_contents));
+
+	
+	
+	_Meta->setElementSize(sizeof(domFx_annotate_type_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domFx_annotate_type_common::domBool::create(daeInt bytes)
+{
+	domFx_annotate_type_common::domBoolRef ref = new(bytes) domFx_annotate_type_common::domBool;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domBool::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "bool" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domBool::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domBool::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_annotate_type_common::domBool2Ref ref = new(bytes) domFx_annotate_type_common::domBool2;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domBool2::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "bool2" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domBool2::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domBool2::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_annotate_type_common::domBool3Ref ref = new(bytes) domFx_annotate_type_common::domBool3;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domBool3::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "bool3" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domBool3::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domBool3::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_annotate_type_common::domBool4Ref ref = new(bytes) domFx_annotate_type_common::domBool4;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domBool4::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "bool4" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domBool4::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domBool4::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_annotate_type_common::domIntRef ref = new(bytes) domFx_annotate_type_common::domInt;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domInt::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "int" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domInt::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domInt::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_annotate_type_common::domInt2Ref ref = new(bytes) domFx_annotate_type_common::domInt2;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domInt2::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "int2" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domInt2::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domInt2::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_annotate_type_common::domInt3Ref ref = new(bytes) domFx_annotate_type_common::domInt3;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domInt3::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "int3" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domInt3::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domInt3::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_annotate_type_common::domInt4Ref ref = new(bytes) domFx_annotate_type_common::domInt4;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domInt4::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "int4" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domInt4::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domInt4::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_annotate_type_common::domFloatRef ref = new(bytes) domFx_annotate_type_common::domFloat;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domFloat::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domFloat::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domFloat::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_annotate_type_common::domFloat2Ref ref = new(bytes) domFx_annotate_type_common::domFloat2;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domFloat2::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float2" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domFloat2::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domFloat2::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_annotate_type_common::domFloat3Ref ref = new(bytes) domFx_annotate_type_common::domFloat3;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domFloat3::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float3" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domFloat3::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domFloat3::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_annotate_type_common::domFloat4Ref ref = new(bytes) domFx_annotate_type_common::domFloat4;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domFloat4::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float4" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domFloat4::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domFloat4::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_annotate_type_common::domFloat2x2Ref ref = new(bytes) domFx_annotate_type_common::domFloat2x2;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domFloat2x2::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float2x2" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domFloat2x2::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domFloat2x2::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_annotate_type_common::domFloat3x3Ref ref = new(bytes) domFx_annotate_type_common::domFloat3x3;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domFloat3x3::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float3x3" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domFloat3x3::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domFloat3x3::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_annotate_type_common::domFloat4x4Ref ref = new(bytes) domFx_annotate_type_common::domFloat4x4;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domFloat4x4::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float4x4" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domFloat4x4::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domFloat4x4::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_annotate_type_common::domStringRef ref = new(bytes) domFx_annotate_type_common::domString;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_annotate_type_common::domString::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "string" );
+	_Meta->setStaticPointerAddress(&domFx_annotate_type_common::domString::_Meta);
+	_Meta->registerConstructor(domFx_annotate_type_common::domString::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domFx_annotate_type_common::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domBool::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domBool2::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domBool3::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domBool4::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domInt::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domInt2::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domInt3::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domInt4::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domFloat::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domFloat2::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domFloat3::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domFloat4::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domFloat2x2::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domFloat3x3::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domFloat4x4::_Meta = NULL;
+daeMetaElement * domFx_annotate_type_common::domString::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_clearcolor_common.cpp

@@ -0,0 +1,68 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_clearcolor_common.h>
+
+daeElementRef
+domFx_clearcolor_common::create(daeInt bytes)
+{
+	domFx_clearcolor_commonRef ref = new(bytes) domFx_clearcolor_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_clearcolor_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_clearcolor_common" );
+	_Meta->setStaticPointerAddress(&domFx_clearcolor_common::_Meta);
+	_Meta->registerConstructor(domFx_clearcolor_common::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("xsNonNegativeInteger"));
+		ma->setOffset( daeOffsetOf( domFx_clearcolor_common , attrIndex ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "0");
+		ma->setIsRequired( false );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domFx_clearcolor_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domFx_clearcolor_common::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_cleardepth_common.cpp

@@ -0,0 +1,68 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_cleardepth_common.h>
+
+daeElementRef
+domFx_cleardepth_common::create(daeInt bytes)
+{
+	domFx_cleardepth_commonRef ref = new(bytes) domFx_cleardepth_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_cleardepth_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_cleardepth_common" );
+	_Meta->setStaticPointerAddress(&domFx_cleardepth_common::_Meta);
+	_Meta->registerConstructor(domFx_cleardepth_common::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("xsNonNegativeInteger"));
+		ma->setOffset( daeOffsetOf( domFx_cleardepth_common , attrIndex ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "0");
+		ma->setIsRequired( false );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domFx_cleardepth_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domFx_cleardepth_common::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_clearstencil_common.cpp

@@ -0,0 +1,68 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_clearstencil_common.h>
+
+daeElementRef
+domFx_clearstencil_common::create(daeInt bytes)
+{
+	domFx_clearstencil_commonRef ref = new(bytes) domFx_clearstencil_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_clearstencil_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_clearstencil_common" );
+	_Meta->setStaticPointerAddress(&domFx_clearstencil_common::_Meta);
+	_Meta->registerConstructor(domFx_clearstencil_common::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("xsNonNegativeInteger"));
+		ma->setOffset( daeOffsetOf( domFx_clearstencil_common , attrIndex ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "0");
+		ma->setIsRequired( false );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domFx_clearstencil_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domFx_clearstencil_common::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_code_profile.cpp

@@ -0,0 +1,67 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_code_profile.h>
+
+daeElementRef
+domFx_code_profile::create(daeInt bytes)
+{
+	domFx_code_profileRef ref = new(bytes) domFx_code_profile;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_code_profile::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_code_profile" );
+	_Meta->setStaticPointerAddress(&domFx_code_profile::_Meta);
+	_Meta->registerConstructor(domFx_code_profile::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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;
+}
+
+
+daeMetaElement * domFx_code_profile::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_colortarget_common.cpp

@@ -0,0 +1,81 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_colortarget_common.h>
+
+daeElementRef
+domFx_colortarget_common::create(daeInt bytes)
+{
+	domFx_colortarget_commonRef ref = new(bytes) domFx_colortarget_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_colortarget_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_colortarget_common" );
+	_Meta->setStaticPointerAddress(&domFx_colortarget_common::_Meta);
+	_Meta->registerConstructor(domFx_colortarget_common::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("xsNonNegativeInteger"));
+		ma->setOffset( daeOffsetOf( domFx_colortarget_common , attrIndex ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "0");
+		ma->setIsRequired( false );
+	
+		_Meta->appendAttribute(ma);
+	}
+
+	//	Add attribute: slice
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "slice" );
+		ma->setType( daeAtomicType::get("xsNonNegativeInteger"));
+		ma->setOffset( daeOffsetOf( domFx_colortarget_common , attrSlice ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "0");
+		ma->setIsRequired( false );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domFx_colortarget_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domFx_colortarget_common::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_depthtarget_common.cpp

@@ -0,0 +1,81 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_depthtarget_common.h>
+
+daeElementRef
+domFx_depthtarget_common::create(daeInt bytes)
+{
+	domFx_depthtarget_commonRef ref = new(bytes) domFx_depthtarget_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_depthtarget_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_depthtarget_common" );
+	_Meta->setStaticPointerAddress(&domFx_depthtarget_common::_Meta);
+	_Meta->registerConstructor(domFx_depthtarget_common::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("xsNonNegativeInteger"));
+		ma->setOffset( daeOffsetOf( domFx_depthtarget_common , attrIndex ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "0");
+		ma->setIsRequired( false );
+	
+		_Meta->appendAttribute(ma);
+	}
+
+	//	Add attribute: slice
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "slice" );
+		ma->setType( daeAtomicType::get("xsNonNegativeInteger"));
+		ma->setOffset( daeOffsetOf( domFx_depthtarget_common , attrSlice ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "0");
+		ma->setIsRequired( false );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domFx_depthtarget_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domFx_depthtarget_common::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_include_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/daeDom.h>
+#include <dom/domFx_include_common.h>
+
+daeElementRef
+domFx_include_common::create(daeInt bytes)
+{
+	domFx_include_commonRef ref = new(bytes) domFx_include_common;
+	ref->attrUrl.setContainer( (domFx_include_common*)ref );
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_include_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_include_common" );
+	_Meta->setStaticPointerAddress(&domFx_include_common::_Meta);
+	_Meta->registerConstructor(domFx_include_common::create);
+
+
+	//	Add attribute: sid
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "sid" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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;
+}
+
+
+daeMetaElement * domFx_include_common::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_newparam_common.cpp

@@ -0,0 +1,171 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_newparam_common.h>
+
+daeElementRef
+domFx_newparam_common::create(daeInt bytes)
+{
+	domFx_newparam_commonRef ref = new(bytes) domFx_newparam_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_newparam_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_newparam_common" );
+	_Meta->setStaticPointerAddress(&domFx_newparam_common::_Meta);
+	_Meta->registerConstructor(domFx_newparam_common::create);
+
+	// Add elements: annotate, semantic, modifier, fx_basic_type_common
+    _Meta->appendArrayElement(domFx_annotate_common::registerElement(),daeOffsetOf(domFx_newparam_common,elemAnnotate_array),"annotate"); 
+    _Meta->appendElement(domFx_newparam_common::domSemantic::registerElement(),daeOffsetOf(domFx_newparam_common,elemSemantic));
+    _Meta->appendElement(domFx_newparam_common::domModifier::registerElement(),daeOffsetOf(domFx_newparam_common,elemModifier));
+    _Meta->appendElement(domFx_basic_type_common::registerElement(),daeOffsetOf(domFx_newparam_common,elemFx_basic_type_common));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float1x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float1x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float1x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float1x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "surface", _Meta->getMetaElements()[3], "fx_surface_common");
+	_Meta->appendPossibleChild( "sampler1D", _Meta->getMetaElements()[3], "fx_sampler1D_common");
+	_Meta->appendPossibleChild( "sampler2D", _Meta->getMetaElements()[3], "fx_sampler2D_common");
+	_Meta->appendPossibleChild( "sampler3D", _Meta->getMetaElements()[3], "fx_sampler3D_common");
+	_Meta->appendPossibleChild( "samplerCUBE", _Meta->getMetaElements()[3], "fx_samplerCUBE_common");
+	_Meta->appendPossibleChild( "samplerRECT", _Meta->getMetaElements()[3], "fx_samplerRECT_common");
+	_Meta->appendPossibleChild( "samplerDEPTH", _Meta->getMetaElements()[3], "fx_samplerDEPTH_common");
+	_Meta->appendPossibleChild( "enum", _Meta->getMetaElements()[3]);
+
+	//	Add attribute: sid
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "sid" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_newparam_common::domSemanticRef ref = new(bytes) domFx_newparam_common::domSemantic;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_newparam_common::domSemantic::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "semantic" );
+	_Meta->setStaticPointerAddress(&domFx_newparam_common::domSemantic::_Meta);
+	_Meta->registerConstructor(domFx_newparam_common::domSemantic::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_newparam_common::domModifierRef ref = new(bytes) domFx_newparam_common::domModifier;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_newparam_common::domModifier::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "modifier" );
+	_Meta->setStaticPointerAddress(&domFx_newparam_common::domModifier::_Meta);
+	_Meta->registerConstructor(domFx_newparam_common::domModifier::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domFx_newparam_common::_Meta = NULL;
+daeMetaElement * domFx_newparam_common::domSemantic::_Meta = NULL;
+daeMetaElement * domFx_newparam_common::domModifier::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_profile_abstract.cpp

@@ -0,0 +1,47 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_profile_abstract.h>
+
+daeElementRef
+domFx_profile_abstract::create(daeInt bytes)
+{
+	domFx_profile_abstractRef ref = new(bytes) domFx_profile_abstract;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_profile_abstract::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_profile_abstract" );
+	_Meta->setStaticPointerAddress(&domFx_profile_abstract::_Meta);
+	_Meta->registerConstructor(domFx_profile_abstract::create);
+
+	_Meta->setIsAbstract( true );
+	
+	
+	_Meta->setElementSize(sizeof(domFx_profile_abstract));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domFx_profile_abstract::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_sampler1D_common.cpp

@@ -0,0 +1,343 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_sampler1D_common.h>
+
+daeElementRef
+domFx_sampler1D_common::create(daeInt bytes)
+{
+	domFx_sampler1D_commonRef ref = new(bytes) domFx_sampler1D_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler1D_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_sampler1D_common" );
+	_Meta->setStaticPointerAddress(&domFx_sampler1D_common::_Meta);
+	_Meta->registerConstructor(domFx_sampler1D_common::create);
+
+	// Add elements: source, wrap_s, minfilter, magfilter, mipfilter, border_color, mipmap_maxlevel, mipmap_bias
+    _Meta->appendElement(domFx_sampler1D_common::domSource::registerElement(),daeOffsetOf(domFx_sampler1D_common,elemSource));
+    _Meta->appendElement(domFx_sampler1D_common::domWrap_s::registerElement(),daeOffsetOf(domFx_sampler1D_common,elemWrap_s));
+    _Meta->appendElement(domFx_sampler1D_common::domMinfilter::registerElement(),daeOffsetOf(domFx_sampler1D_common,elemMinfilter));
+    _Meta->appendElement(domFx_sampler1D_common::domMagfilter::registerElement(),daeOffsetOf(domFx_sampler1D_common,elemMagfilter));
+    _Meta->appendElement(domFx_sampler1D_common::domMipfilter::registerElement(),daeOffsetOf(domFx_sampler1D_common,elemMipfilter));
+    _Meta->appendElement(domFx_sampler1D_common::domBorder_color::registerElement(),daeOffsetOf(domFx_sampler1D_common,elemBorder_color));
+    _Meta->appendElement(domFx_sampler1D_common::domMipmap_maxlevel::registerElement(),daeOffsetOf(domFx_sampler1D_common,elemMipmap_maxlevel));
+    _Meta->appendElement(domFx_sampler1D_common::domMipmap_bias::registerElement(),daeOffsetOf(domFx_sampler1D_common,elemMipmap_bias));
+	
+	
+	_Meta->setElementSize(sizeof(domFx_sampler1D_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domFx_sampler1D_common::domSource::create(daeInt bytes)
+{
+	domFx_sampler1D_common::domSourceRef ref = new(bytes) domFx_sampler1D_common::domSource;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler1D_common::domSource::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "source" );
+	_Meta->setStaticPointerAddress(&domFx_sampler1D_common::domSource::_Meta);
+	_Meta->registerConstructor(domFx_sampler1D_common::domSource::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler1D_common::domWrap_sRef ref = new(bytes) domFx_sampler1D_common::domWrap_s;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler1D_common::domWrap_s::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "wrap_s" );
+	_Meta->setStaticPointerAddress(&domFx_sampler1D_common::domWrap_s::_Meta);
+	_Meta->registerConstructor(domFx_sampler1D_common::domWrap_s::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler1D_common::domMinfilterRef ref = new(bytes) domFx_sampler1D_common::domMinfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler1D_common::domMinfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "minfilter" );
+	_Meta->setStaticPointerAddress(&domFx_sampler1D_common::domMinfilter::_Meta);
+	_Meta->registerConstructor(domFx_sampler1D_common::domMinfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler1D_common::domMagfilterRef ref = new(bytes) domFx_sampler1D_common::domMagfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler1D_common::domMagfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "magfilter" );
+	_Meta->setStaticPointerAddress(&domFx_sampler1D_common::domMagfilter::_Meta);
+	_Meta->registerConstructor(domFx_sampler1D_common::domMagfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler1D_common::domMipfilterRef ref = new(bytes) domFx_sampler1D_common::domMipfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler1D_common::domMipfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipfilter" );
+	_Meta->setStaticPointerAddress(&domFx_sampler1D_common::domMipfilter::_Meta);
+	_Meta->registerConstructor(domFx_sampler1D_common::domMipfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler1D_common::domBorder_colorRef ref = new(bytes) domFx_sampler1D_common::domBorder_color;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler1D_common::domBorder_color::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "border_color" );
+	_Meta->setStaticPointerAddress(&domFx_sampler1D_common::domBorder_color::_Meta);
+	_Meta->registerConstructor(domFx_sampler1D_common::domBorder_color::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler1D_common::domMipmap_maxlevelRef ref = new(bytes) domFx_sampler1D_common::domMipmap_maxlevel;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler1D_common::domMipmap_maxlevel::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipmap_maxlevel" );
+	_Meta->setStaticPointerAddress(&domFx_sampler1D_common::domMipmap_maxlevel::_Meta);
+	_Meta->registerConstructor(domFx_sampler1D_common::domMipmap_maxlevel::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler1D_common::domMipmap_biasRef ref = new(bytes) domFx_sampler1D_common::domMipmap_bias;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler1D_common::domMipmap_bias::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipmap_bias" );
+	_Meta->setStaticPointerAddress(&domFx_sampler1D_common::domMipmap_bias::_Meta);
+	_Meta->registerConstructor(domFx_sampler1D_common::domMipmap_bias::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domFx_sampler1D_common::_Meta = NULL;
+daeMetaElement * domFx_sampler1D_common::domSource::_Meta = NULL;
+daeMetaElement * domFx_sampler1D_common::domWrap_s::_Meta = NULL;
+daeMetaElement * domFx_sampler1D_common::domMinfilter::_Meta = NULL;
+daeMetaElement * domFx_sampler1D_common::domMagfilter::_Meta = NULL;
+daeMetaElement * domFx_sampler1D_common::domMipfilter::_Meta = NULL;
+daeMetaElement * domFx_sampler1D_common::domBorder_color::_Meta = NULL;
+daeMetaElement * domFx_sampler1D_common::domMipmap_maxlevel::_Meta = NULL;
+daeMetaElement * domFx_sampler1D_common::domMipmap_bias::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_sampler2D_common.cpp

@@ -0,0 +1,380 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_sampler2D_common.h>
+
+daeElementRef
+domFx_sampler2D_common::create(daeInt bytes)
+{
+	domFx_sampler2D_commonRef ref = new(bytes) domFx_sampler2D_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler2D_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_sampler2D_common" );
+	_Meta->setStaticPointerAddress(&domFx_sampler2D_common::_Meta);
+	_Meta->registerConstructor(domFx_sampler2D_common::create);
+
+	// Add elements: source, wrap_s, wrap_t, minfilter, magfilter, mipfilter, border_color, mipmap_maxlevel, mipmap_bias
+    _Meta->appendElement(domFx_sampler2D_common::domSource::registerElement(),daeOffsetOf(domFx_sampler2D_common,elemSource));
+    _Meta->appendElement(domFx_sampler2D_common::domWrap_s::registerElement(),daeOffsetOf(domFx_sampler2D_common,elemWrap_s));
+    _Meta->appendElement(domFx_sampler2D_common::domWrap_t::registerElement(),daeOffsetOf(domFx_sampler2D_common,elemWrap_t));
+    _Meta->appendElement(domFx_sampler2D_common::domMinfilter::registerElement(),daeOffsetOf(domFx_sampler2D_common,elemMinfilter));
+    _Meta->appendElement(domFx_sampler2D_common::domMagfilter::registerElement(),daeOffsetOf(domFx_sampler2D_common,elemMagfilter));
+    _Meta->appendElement(domFx_sampler2D_common::domMipfilter::registerElement(),daeOffsetOf(domFx_sampler2D_common,elemMipfilter));
+    _Meta->appendElement(domFx_sampler2D_common::domBorder_color::registerElement(),daeOffsetOf(domFx_sampler2D_common,elemBorder_color));
+    _Meta->appendElement(domFx_sampler2D_common::domMipmap_maxlevel::registerElement(),daeOffsetOf(domFx_sampler2D_common,elemMipmap_maxlevel));
+    _Meta->appendElement(domFx_sampler2D_common::domMipmap_bias::registerElement(),daeOffsetOf(domFx_sampler2D_common,elemMipmap_bias));
+	
+	
+	_Meta->setElementSize(sizeof(domFx_sampler2D_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domFx_sampler2D_common::domSource::create(daeInt bytes)
+{
+	domFx_sampler2D_common::domSourceRef ref = new(bytes) domFx_sampler2D_common::domSource;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler2D_common::domSource::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "source" );
+	_Meta->setStaticPointerAddress(&domFx_sampler2D_common::domSource::_Meta);
+	_Meta->registerConstructor(domFx_sampler2D_common::domSource::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler2D_common::domWrap_sRef ref = new(bytes) domFx_sampler2D_common::domWrap_s;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler2D_common::domWrap_s::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "wrap_s" );
+	_Meta->setStaticPointerAddress(&domFx_sampler2D_common::domWrap_s::_Meta);
+	_Meta->registerConstructor(domFx_sampler2D_common::domWrap_s::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler2D_common::domWrap_tRef ref = new(bytes) domFx_sampler2D_common::domWrap_t;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler2D_common::domWrap_t::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "wrap_t" );
+	_Meta->setStaticPointerAddress(&domFx_sampler2D_common::domWrap_t::_Meta);
+	_Meta->registerConstructor(domFx_sampler2D_common::domWrap_t::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler2D_common::domMinfilterRef ref = new(bytes) domFx_sampler2D_common::domMinfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler2D_common::domMinfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "minfilter" );
+	_Meta->setStaticPointerAddress(&domFx_sampler2D_common::domMinfilter::_Meta);
+	_Meta->registerConstructor(domFx_sampler2D_common::domMinfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler2D_common::domMagfilterRef ref = new(bytes) domFx_sampler2D_common::domMagfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler2D_common::domMagfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "magfilter" );
+	_Meta->setStaticPointerAddress(&domFx_sampler2D_common::domMagfilter::_Meta);
+	_Meta->registerConstructor(domFx_sampler2D_common::domMagfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler2D_common::domMipfilterRef ref = new(bytes) domFx_sampler2D_common::domMipfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler2D_common::domMipfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipfilter" );
+	_Meta->setStaticPointerAddress(&domFx_sampler2D_common::domMipfilter::_Meta);
+	_Meta->registerConstructor(domFx_sampler2D_common::domMipfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler2D_common::domBorder_colorRef ref = new(bytes) domFx_sampler2D_common::domBorder_color;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler2D_common::domBorder_color::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "border_color" );
+	_Meta->setStaticPointerAddress(&domFx_sampler2D_common::domBorder_color::_Meta);
+	_Meta->registerConstructor(domFx_sampler2D_common::domBorder_color::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler2D_common::domMipmap_maxlevelRef ref = new(bytes) domFx_sampler2D_common::domMipmap_maxlevel;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler2D_common::domMipmap_maxlevel::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipmap_maxlevel" );
+	_Meta->setStaticPointerAddress(&domFx_sampler2D_common::domMipmap_maxlevel::_Meta);
+	_Meta->registerConstructor(domFx_sampler2D_common::domMipmap_maxlevel::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler2D_common::domMipmap_biasRef ref = new(bytes) domFx_sampler2D_common::domMipmap_bias;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler2D_common::domMipmap_bias::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipmap_bias" );
+	_Meta->setStaticPointerAddress(&domFx_sampler2D_common::domMipmap_bias::_Meta);
+	_Meta->registerConstructor(domFx_sampler2D_common::domMipmap_bias::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domFx_sampler2D_common::_Meta = NULL;
+daeMetaElement * domFx_sampler2D_common::domSource::_Meta = NULL;
+daeMetaElement * domFx_sampler2D_common::domWrap_s::_Meta = NULL;
+daeMetaElement * domFx_sampler2D_common::domWrap_t::_Meta = NULL;
+daeMetaElement * domFx_sampler2D_common::domMinfilter::_Meta = NULL;
+daeMetaElement * domFx_sampler2D_common::domMagfilter::_Meta = NULL;
+daeMetaElement * domFx_sampler2D_common::domMipfilter::_Meta = NULL;
+daeMetaElement * domFx_sampler2D_common::domBorder_color::_Meta = NULL;
+daeMetaElement * domFx_sampler2D_common::domMipmap_maxlevel::_Meta = NULL;
+daeMetaElement * domFx_sampler2D_common::domMipmap_bias::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_sampler3D_common.cpp

@@ -0,0 +1,417 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_sampler3D_common.h>
+
+daeElementRef
+domFx_sampler3D_common::create(daeInt bytes)
+{
+	domFx_sampler3D_commonRef ref = new(bytes) domFx_sampler3D_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler3D_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_sampler3D_common" );
+	_Meta->setStaticPointerAddress(&domFx_sampler3D_common::_Meta);
+	_Meta->registerConstructor(domFx_sampler3D_common::create);
+
+	// Add elements: source, wrap_s, wrap_t, wrap_p, minfilter, magfilter, mipfilter, border_color, mipmap_maxlevel, mipmap_bias
+    _Meta->appendElement(domFx_sampler3D_common::domSource::registerElement(),daeOffsetOf(domFx_sampler3D_common,elemSource));
+    _Meta->appendElement(domFx_sampler3D_common::domWrap_s::registerElement(),daeOffsetOf(domFx_sampler3D_common,elemWrap_s));
+    _Meta->appendElement(domFx_sampler3D_common::domWrap_t::registerElement(),daeOffsetOf(domFx_sampler3D_common,elemWrap_t));
+    _Meta->appendElement(domFx_sampler3D_common::domWrap_p::registerElement(),daeOffsetOf(domFx_sampler3D_common,elemWrap_p));
+    _Meta->appendElement(domFx_sampler3D_common::domMinfilter::registerElement(),daeOffsetOf(domFx_sampler3D_common,elemMinfilter));
+    _Meta->appendElement(domFx_sampler3D_common::domMagfilter::registerElement(),daeOffsetOf(domFx_sampler3D_common,elemMagfilter));
+    _Meta->appendElement(domFx_sampler3D_common::domMipfilter::registerElement(),daeOffsetOf(domFx_sampler3D_common,elemMipfilter));
+    _Meta->appendElement(domFx_sampler3D_common::domBorder_color::registerElement(),daeOffsetOf(domFx_sampler3D_common,elemBorder_color));
+    _Meta->appendElement(domFx_sampler3D_common::domMipmap_maxlevel::registerElement(),daeOffsetOf(domFx_sampler3D_common,elemMipmap_maxlevel));
+    _Meta->appendElement(domFx_sampler3D_common::domMipmap_bias::registerElement(),daeOffsetOf(domFx_sampler3D_common,elemMipmap_bias));
+	
+	
+	_Meta->setElementSize(sizeof(domFx_sampler3D_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domFx_sampler3D_common::domSource::create(daeInt bytes)
+{
+	domFx_sampler3D_common::domSourceRef ref = new(bytes) domFx_sampler3D_common::domSource;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler3D_common::domSource::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "source" );
+	_Meta->setStaticPointerAddress(&domFx_sampler3D_common::domSource::_Meta);
+	_Meta->registerConstructor(domFx_sampler3D_common::domSource::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler3D_common::domWrap_sRef ref = new(bytes) domFx_sampler3D_common::domWrap_s;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler3D_common::domWrap_s::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "wrap_s" );
+	_Meta->setStaticPointerAddress(&domFx_sampler3D_common::domWrap_s::_Meta);
+	_Meta->registerConstructor(domFx_sampler3D_common::domWrap_s::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler3D_common::domWrap_tRef ref = new(bytes) domFx_sampler3D_common::domWrap_t;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler3D_common::domWrap_t::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "wrap_t" );
+	_Meta->setStaticPointerAddress(&domFx_sampler3D_common::domWrap_t::_Meta);
+	_Meta->registerConstructor(domFx_sampler3D_common::domWrap_t::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler3D_common::domWrap_pRef ref = new(bytes) domFx_sampler3D_common::domWrap_p;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler3D_common::domWrap_p::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "wrap_p" );
+	_Meta->setStaticPointerAddress(&domFx_sampler3D_common::domWrap_p::_Meta);
+	_Meta->registerConstructor(domFx_sampler3D_common::domWrap_p::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler3D_common::domMinfilterRef ref = new(bytes) domFx_sampler3D_common::domMinfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler3D_common::domMinfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "minfilter" );
+	_Meta->setStaticPointerAddress(&domFx_sampler3D_common::domMinfilter::_Meta);
+	_Meta->registerConstructor(domFx_sampler3D_common::domMinfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler3D_common::domMagfilterRef ref = new(bytes) domFx_sampler3D_common::domMagfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler3D_common::domMagfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "magfilter" );
+	_Meta->setStaticPointerAddress(&domFx_sampler3D_common::domMagfilter::_Meta);
+	_Meta->registerConstructor(domFx_sampler3D_common::domMagfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler3D_common::domMipfilterRef ref = new(bytes) domFx_sampler3D_common::domMipfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler3D_common::domMipfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipfilter" );
+	_Meta->setStaticPointerAddress(&domFx_sampler3D_common::domMipfilter::_Meta);
+	_Meta->registerConstructor(domFx_sampler3D_common::domMipfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler3D_common::domBorder_colorRef ref = new(bytes) domFx_sampler3D_common::domBorder_color;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler3D_common::domBorder_color::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "border_color" );
+	_Meta->setStaticPointerAddress(&domFx_sampler3D_common::domBorder_color::_Meta);
+	_Meta->registerConstructor(domFx_sampler3D_common::domBorder_color::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler3D_common::domMipmap_maxlevelRef ref = new(bytes) domFx_sampler3D_common::domMipmap_maxlevel;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler3D_common::domMipmap_maxlevel::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipmap_maxlevel" );
+	_Meta->setStaticPointerAddress(&domFx_sampler3D_common::domMipmap_maxlevel::_Meta);
+	_Meta->registerConstructor(domFx_sampler3D_common::domMipmap_maxlevel::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_sampler3D_common::domMipmap_biasRef ref = new(bytes) domFx_sampler3D_common::domMipmap_bias;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_sampler3D_common::domMipmap_bias::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipmap_bias" );
+	_Meta->setStaticPointerAddress(&domFx_sampler3D_common::domMipmap_bias::_Meta);
+	_Meta->registerConstructor(domFx_sampler3D_common::domMipmap_bias::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domFx_sampler3D_common::_Meta = NULL;
+daeMetaElement * domFx_sampler3D_common::domSource::_Meta = NULL;
+daeMetaElement * domFx_sampler3D_common::domWrap_s::_Meta = NULL;
+daeMetaElement * domFx_sampler3D_common::domWrap_t::_Meta = NULL;
+daeMetaElement * domFx_sampler3D_common::domWrap_p::_Meta = NULL;
+daeMetaElement * domFx_sampler3D_common::domMinfilter::_Meta = NULL;
+daeMetaElement * domFx_sampler3D_common::domMagfilter::_Meta = NULL;
+daeMetaElement * domFx_sampler3D_common::domMipfilter::_Meta = NULL;
+daeMetaElement * domFx_sampler3D_common::domBorder_color::_Meta = NULL;
+daeMetaElement * domFx_sampler3D_common::domMipmap_maxlevel::_Meta = NULL;
+daeMetaElement * domFx_sampler3D_common::domMipmap_bias::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_samplerCUBE_common.cpp

@@ -0,0 +1,417 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_samplerCUBE_common.h>
+
+daeElementRef
+domFx_samplerCUBE_common::create(daeInt bytes)
+{
+	domFx_samplerCUBE_commonRef ref = new(bytes) domFx_samplerCUBE_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerCUBE_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_samplerCUBE_common" );
+	_Meta->setStaticPointerAddress(&domFx_samplerCUBE_common::_Meta);
+	_Meta->registerConstructor(domFx_samplerCUBE_common::create);
+
+	// Add elements: source, wrap_s, wrap_t, wrap_p, minfilter, magfilter, mipfilter, border_color, mipmap_maxlevel, mipmap_bias
+    _Meta->appendElement(domFx_samplerCUBE_common::domSource::registerElement(),daeOffsetOf(domFx_samplerCUBE_common,elemSource));
+    _Meta->appendElement(domFx_samplerCUBE_common::domWrap_s::registerElement(),daeOffsetOf(domFx_samplerCUBE_common,elemWrap_s));
+    _Meta->appendElement(domFx_samplerCUBE_common::domWrap_t::registerElement(),daeOffsetOf(domFx_samplerCUBE_common,elemWrap_t));
+    _Meta->appendElement(domFx_samplerCUBE_common::domWrap_p::registerElement(),daeOffsetOf(domFx_samplerCUBE_common,elemWrap_p));
+    _Meta->appendElement(domFx_samplerCUBE_common::domMinfilter::registerElement(),daeOffsetOf(domFx_samplerCUBE_common,elemMinfilter));
+    _Meta->appendElement(domFx_samplerCUBE_common::domMagfilter::registerElement(),daeOffsetOf(domFx_samplerCUBE_common,elemMagfilter));
+    _Meta->appendElement(domFx_samplerCUBE_common::domMipfilter::registerElement(),daeOffsetOf(domFx_samplerCUBE_common,elemMipfilter));
+    _Meta->appendElement(domFx_samplerCUBE_common::domBorder_color::registerElement(),daeOffsetOf(domFx_samplerCUBE_common,elemBorder_color));
+    _Meta->appendElement(domFx_samplerCUBE_common::domMipmap_maxlevel::registerElement(),daeOffsetOf(domFx_samplerCUBE_common,elemMipmap_maxlevel));
+    _Meta->appendElement(domFx_samplerCUBE_common::domMipmap_bias::registerElement(),daeOffsetOf(domFx_samplerCUBE_common,elemMipmap_bias));
+	
+	
+	_Meta->setElementSize(sizeof(domFx_samplerCUBE_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domFx_samplerCUBE_common::domSource::create(daeInt bytes)
+{
+	domFx_samplerCUBE_common::domSourceRef ref = new(bytes) domFx_samplerCUBE_common::domSource;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerCUBE_common::domSource::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "source" );
+	_Meta->setStaticPointerAddress(&domFx_samplerCUBE_common::domSource::_Meta);
+	_Meta->registerConstructor(domFx_samplerCUBE_common::domSource::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerCUBE_common::domWrap_sRef ref = new(bytes) domFx_samplerCUBE_common::domWrap_s;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerCUBE_common::domWrap_s::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "wrap_s" );
+	_Meta->setStaticPointerAddress(&domFx_samplerCUBE_common::domWrap_s::_Meta);
+	_Meta->registerConstructor(domFx_samplerCUBE_common::domWrap_s::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerCUBE_common::domWrap_tRef ref = new(bytes) domFx_samplerCUBE_common::domWrap_t;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerCUBE_common::domWrap_t::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "wrap_t" );
+	_Meta->setStaticPointerAddress(&domFx_samplerCUBE_common::domWrap_t::_Meta);
+	_Meta->registerConstructor(domFx_samplerCUBE_common::domWrap_t::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerCUBE_common::domWrap_pRef ref = new(bytes) domFx_samplerCUBE_common::domWrap_p;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerCUBE_common::domWrap_p::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "wrap_p" );
+	_Meta->setStaticPointerAddress(&domFx_samplerCUBE_common::domWrap_p::_Meta);
+	_Meta->registerConstructor(domFx_samplerCUBE_common::domWrap_p::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerCUBE_common::domMinfilterRef ref = new(bytes) domFx_samplerCUBE_common::domMinfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerCUBE_common::domMinfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "minfilter" );
+	_Meta->setStaticPointerAddress(&domFx_samplerCUBE_common::domMinfilter::_Meta);
+	_Meta->registerConstructor(domFx_samplerCUBE_common::domMinfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerCUBE_common::domMagfilterRef ref = new(bytes) domFx_samplerCUBE_common::domMagfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerCUBE_common::domMagfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "magfilter" );
+	_Meta->setStaticPointerAddress(&domFx_samplerCUBE_common::domMagfilter::_Meta);
+	_Meta->registerConstructor(domFx_samplerCUBE_common::domMagfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerCUBE_common::domMipfilterRef ref = new(bytes) domFx_samplerCUBE_common::domMipfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerCUBE_common::domMipfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipfilter" );
+	_Meta->setStaticPointerAddress(&domFx_samplerCUBE_common::domMipfilter::_Meta);
+	_Meta->registerConstructor(domFx_samplerCUBE_common::domMipfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerCUBE_common::domBorder_colorRef ref = new(bytes) domFx_samplerCUBE_common::domBorder_color;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerCUBE_common::domBorder_color::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "border_color" );
+	_Meta->setStaticPointerAddress(&domFx_samplerCUBE_common::domBorder_color::_Meta);
+	_Meta->registerConstructor(domFx_samplerCUBE_common::domBorder_color::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerCUBE_common::domMipmap_maxlevelRef ref = new(bytes) domFx_samplerCUBE_common::domMipmap_maxlevel;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerCUBE_common::domMipmap_maxlevel::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipmap_maxlevel" );
+	_Meta->setStaticPointerAddress(&domFx_samplerCUBE_common::domMipmap_maxlevel::_Meta);
+	_Meta->registerConstructor(domFx_samplerCUBE_common::domMipmap_maxlevel::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerCUBE_common::domMipmap_biasRef ref = new(bytes) domFx_samplerCUBE_common::domMipmap_bias;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerCUBE_common::domMipmap_bias::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipmap_bias" );
+	_Meta->setStaticPointerAddress(&domFx_samplerCUBE_common::domMipmap_bias::_Meta);
+	_Meta->registerConstructor(domFx_samplerCUBE_common::domMipmap_bias::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domFx_samplerCUBE_common::_Meta = NULL;
+daeMetaElement * domFx_samplerCUBE_common::domSource::_Meta = NULL;
+daeMetaElement * domFx_samplerCUBE_common::domWrap_s::_Meta = NULL;
+daeMetaElement * domFx_samplerCUBE_common::domWrap_t::_Meta = NULL;
+daeMetaElement * domFx_samplerCUBE_common::domWrap_p::_Meta = NULL;
+daeMetaElement * domFx_samplerCUBE_common::domMinfilter::_Meta = NULL;
+daeMetaElement * domFx_samplerCUBE_common::domMagfilter::_Meta = NULL;
+daeMetaElement * domFx_samplerCUBE_common::domMipfilter::_Meta = NULL;
+daeMetaElement * domFx_samplerCUBE_common::domBorder_color::_Meta = NULL;
+daeMetaElement * domFx_samplerCUBE_common::domMipmap_maxlevel::_Meta = NULL;
+daeMetaElement * domFx_samplerCUBE_common::domMipmap_bias::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_samplerDEPTH_common.cpp

@@ -0,0 +1,232 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_samplerDEPTH_common.h>
+
+daeElementRef
+domFx_samplerDEPTH_common::create(daeInt bytes)
+{
+	domFx_samplerDEPTH_commonRef ref = new(bytes) domFx_samplerDEPTH_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerDEPTH_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_samplerDEPTH_common" );
+	_Meta->setStaticPointerAddress(&domFx_samplerDEPTH_common::_Meta);
+	_Meta->registerConstructor(domFx_samplerDEPTH_common::create);
+
+	// Add elements: source, wrap_s, wrap_t, minfilter, magfilter
+    _Meta->appendElement(domFx_samplerDEPTH_common::domSource::registerElement(),daeOffsetOf(domFx_samplerDEPTH_common,elemSource));
+    _Meta->appendElement(domFx_samplerDEPTH_common::domWrap_s::registerElement(),daeOffsetOf(domFx_samplerDEPTH_common,elemWrap_s));
+    _Meta->appendElement(domFx_samplerDEPTH_common::domWrap_t::registerElement(),daeOffsetOf(domFx_samplerDEPTH_common,elemWrap_t));
+    _Meta->appendElement(domFx_samplerDEPTH_common::domMinfilter::registerElement(),daeOffsetOf(domFx_samplerDEPTH_common,elemMinfilter));
+    _Meta->appendElement(domFx_samplerDEPTH_common::domMagfilter::registerElement(),daeOffsetOf(domFx_samplerDEPTH_common,elemMagfilter));
+	
+	
+	_Meta->setElementSize(sizeof(domFx_samplerDEPTH_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domFx_samplerDEPTH_common::domSource::create(daeInt bytes)
+{
+	domFx_samplerDEPTH_common::domSourceRef ref = new(bytes) domFx_samplerDEPTH_common::domSource;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerDEPTH_common::domSource::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "source" );
+	_Meta->setStaticPointerAddress(&domFx_samplerDEPTH_common::domSource::_Meta);
+	_Meta->registerConstructor(domFx_samplerDEPTH_common::domSource::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerDEPTH_common::domWrap_sRef ref = new(bytes) domFx_samplerDEPTH_common::domWrap_s;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerDEPTH_common::domWrap_s::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "wrap_s" );
+	_Meta->setStaticPointerAddress(&domFx_samplerDEPTH_common::domWrap_s::_Meta);
+	_Meta->registerConstructor(domFx_samplerDEPTH_common::domWrap_s::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerDEPTH_common::domWrap_tRef ref = new(bytes) domFx_samplerDEPTH_common::domWrap_t;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerDEPTH_common::domWrap_t::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "wrap_t" );
+	_Meta->setStaticPointerAddress(&domFx_samplerDEPTH_common::domWrap_t::_Meta);
+	_Meta->registerConstructor(domFx_samplerDEPTH_common::domWrap_t::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerDEPTH_common::domMinfilterRef ref = new(bytes) domFx_samplerDEPTH_common::domMinfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerDEPTH_common::domMinfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "minfilter" );
+	_Meta->setStaticPointerAddress(&domFx_samplerDEPTH_common::domMinfilter::_Meta);
+	_Meta->registerConstructor(domFx_samplerDEPTH_common::domMinfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerDEPTH_common::domMagfilterRef ref = new(bytes) domFx_samplerDEPTH_common::domMagfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerDEPTH_common::domMagfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "magfilter" );
+	_Meta->setStaticPointerAddress(&domFx_samplerDEPTH_common::domMagfilter::_Meta);
+	_Meta->registerConstructor(domFx_samplerDEPTH_common::domMagfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domFx_samplerDEPTH_common::_Meta = NULL;
+daeMetaElement * domFx_samplerDEPTH_common::domSource::_Meta = NULL;
+daeMetaElement * domFx_samplerDEPTH_common::domWrap_s::_Meta = NULL;
+daeMetaElement * domFx_samplerDEPTH_common::domWrap_t::_Meta = NULL;
+daeMetaElement * domFx_samplerDEPTH_common::domMinfilter::_Meta = NULL;
+daeMetaElement * domFx_samplerDEPTH_common::domMagfilter::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_samplerRECT_common.cpp

@@ -0,0 +1,380 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_samplerRECT_common.h>
+
+daeElementRef
+domFx_samplerRECT_common::create(daeInt bytes)
+{
+	domFx_samplerRECT_commonRef ref = new(bytes) domFx_samplerRECT_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerRECT_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_samplerRECT_common" );
+	_Meta->setStaticPointerAddress(&domFx_samplerRECT_common::_Meta);
+	_Meta->registerConstructor(domFx_samplerRECT_common::create);
+
+	// Add elements: source, wrap_s, wrap_t, minfilter, magfilter, mipfilter, border_color, mipmap_maxlevel, mipmap_bias
+    _Meta->appendElement(domFx_samplerRECT_common::domSource::registerElement(),daeOffsetOf(domFx_samplerRECT_common,elemSource));
+    _Meta->appendElement(domFx_samplerRECT_common::domWrap_s::registerElement(),daeOffsetOf(domFx_samplerRECT_common,elemWrap_s));
+    _Meta->appendElement(domFx_samplerRECT_common::domWrap_t::registerElement(),daeOffsetOf(domFx_samplerRECT_common,elemWrap_t));
+    _Meta->appendElement(domFx_samplerRECT_common::domMinfilter::registerElement(),daeOffsetOf(domFx_samplerRECT_common,elemMinfilter));
+    _Meta->appendElement(domFx_samplerRECT_common::domMagfilter::registerElement(),daeOffsetOf(domFx_samplerRECT_common,elemMagfilter));
+    _Meta->appendElement(domFx_samplerRECT_common::domMipfilter::registerElement(),daeOffsetOf(domFx_samplerRECT_common,elemMipfilter));
+    _Meta->appendElement(domFx_samplerRECT_common::domBorder_color::registerElement(),daeOffsetOf(domFx_samplerRECT_common,elemBorder_color));
+    _Meta->appendElement(domFx_samplerRECT_common::domMipmap_maxlevel::registerElement(),daeOffsetOf(domFx_samplerRECT_common,elemMipmap_maxlevel));
+    _Meta->appendElement(domFx_samplerRECT_common::domMipmap_bias::registerElement(),daeOffsetOf(domFx_samplerRECT_common,elemMipmap_bias));
+	
+	
+	_Meta->setElementSize(sizeof(domFx_samplerRECT_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domFx_samplerRECT_common::domSource::create(daeInt bytes)
+{
+	domFx_samplerRECT_common::domSourceRef ref = new(bytes) domFx_samplerRECT_common::domSource;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerRECT_common::domSource::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "source" );
+	_Meta->setStaticPointerAddress(&domFx_samplerRECT_common::domSource::_Meta);
+	_Meta->registerConstructor(domFx_samplerRECT_common::domSource::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerRECT_common::domWrap_sRef ref = new(bytes) domFx_samplerRECT_common::domWrap_s;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerRECT_common::domWrap_s::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "wrap_s" );
+	_Meta->setStaticPointerAddress(&domFx_samplerRECT_common::domWrap_s::_Meta);
+	_Meta->registerConstructor(domFx_samplerRECT_common::domWrap_s::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerRECT_common::domWrap_tRef ref = new(bytes) domFx_samplerRECT_common::domWrap_t;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerRECT_common::domWrap_t::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "wrap_t" );
+	_Meta->setStaticPointerAddress(&domFx_samplerRECT_common::domWrap_t::_Meta);
+	_Meta->registerConstructor(domFx_samplerRECT_common::domWrap_t::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerRECT_common::domMinfilterRef ref = new(bytes) domFx_samplerRECT_common::domMinfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerRECT_common::domMinfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "minfilter" );
+	_Meta->setStaticPointerAddress(&domFx_samplerRECT_common::domMinfilter::_Meta);
+	_Meta->registerConstructor(domFx_samplerRECT_common::domMinfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerRECT_common::domMagfilterRef ref = new(bytes) domFx_samplerRECT_common::domMagfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerRECT_common::domMagfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "magfilter" );
+	_Meta->setStaticPointerAddress(&domFx_samplerRECT_common::domMagfilter::_Meta);
+	_Meta->registerConstructor(domFx_samplerRECT_common::domMagfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerRECT_common::domMipfilterRef ref = new(bytes) domFx_samplerRECT_common::domMipfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerRECT_common::domMipfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipfilter" );
+	_Meta->setStaticPointerAddress(&domFx_samplerRECT_common::domMipfilter::_Meta);
+	_Meta->registerConstructor(domFx_samplerRECT_common::domMipfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerRECT_common::domBorder_colorRef ref = new(bytes) domFx_samplerRECT_common::domBorder_color;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerRECT_common::domBorder_color::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "border_color" );
+	_Meta->setStaticPointerAddress(&domFx_samplerRECT_common::domBorder_color::_Meta);
+	_Meta->registerConstructor(domFx_samplerRECT_common::domBorder_color::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerRECT_common::domMipmap_maxlevelRef ref = new(bytes) domFx_samplerRECT_common::domMipmap_maxlevel;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerRECT_common::domMipmap_maxlevel::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipmap_maxlevel" );
+	_Meta->setStaticPointerAddress(&domFx_samplerRECT_common::domMipmap_maxlevel::_Meta);
+	_Meta->registerConstructor(domFx_samplerRECT_common::domMipmap_maxlevel::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_samplerRECT_common::domMipmap_biasRef ref = new(bytes) domFx_samplerRECT_common::domMipmap_bias;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_samplerRECT_common::domMipmap_bias::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipmap_bias" );
+	_Meta->setStaticPointerAddress(&domFx_samplerRECT_common::domMipmap_bias::_Meta);
+	_Meta->registerConstructor(domFx_samplerRECT_common::domMipmap_bias::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domFx_samplerRECT_common::_Meta = NULL;
+daeMetaElement * domFx_samplerRECT_common::domSource::_Meta = NULL;
+daeMetaElement * domFx_samplerRECT_common::domWrap_s::_Meta = NULL;
+daeMetaElement * domFx_samplerRECT_common::domWrap_t::_Meta = NULL;
+daeMetaElement * domFx_samplerRECT_common::domMinfilter::_Meta = NULL;
+daeMetaElement * domFx_samplerRECT_common::domMagfilter::_Meta = NULL;
+daeMetaElement * domFx_samplerRECT_common::domMipfilter::_Meta = NULL;
+daeMetaElement * domFx_samplerRECT_common::domBorder_color::_Meta = NULL;
+daeMetaElement * domFx_samplerRECT_common::domMipmap_maxlevel::_Meta = NULL;
+daeMetaElement * domFx_samplerRECT_common::domMipmap_bias::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_setparam_common.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/daeDom.h>
+#include <dom/domFx_setparam_common.h>
+
+daeElementRef
+domFx_setparam_common::create(daeInt bytes)
+{
+	domFx_setparam_commonRef ref = new(bytes) domFx_setparam_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_setparam_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_setparam_common" );
+	_Meta->setStaticPointerAddress(&domFx_setparam_common::_Meta);
+	_Meta->registerConstructor(domFx_setparam_common::create);
+
+	// Add elements: annotate, fx_basic_type_common
+    _Meta->appendArrayElement(domFx_annotate_common::registerElement(),daeOffsetOf(domFx_setparam_common,elemAnnotate_array),"annotate"); 
+    _Meta->appendElement(domFx_basic_type_common::registerElement(),daeOffsetOf(domFx_setparam_common,elemFx_basic_type_common));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float1x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float1x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float1x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float1x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float2x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float2x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float2x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float3x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float3x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float3x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float4x1", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float4x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float4x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "surface", _Meta->getMetaElements()[1], "fx_surface_common");
+	_Meta->appendPossibleChild( "sampler1D", _Meta->getMetaElements()[1], "fx_sampler1D_common");
+	_Meta->appendPossibleChild( "sampler2D", _Meta->getMetaElements()[1], "fx_sampler2D_common");
+	_Meta->appendPossibleChild( "sampler3D", _Meta->getMetaElements()[1], "fx_sampler3D_common");
+	_Meta->appendPossibleChild( "samplerCUBE", _Meta->getMetaElements()[1], "fx_samplerCUBE_common");
+	_Meta->appendPossibleChild( "samplerRECT", _Meta->getMetaElements()[1], "fx_samplerRECT_common");
+	_Meta->appendPossibleChild( "samplerDEPTH", _Meta->getMetaElements()[1], "fx_samplerDEPTH_common");
+	_Meta->appendPossibleChild( "enum", _Meta->getMetaElements()[1]);
+
+	//	Add attribute: ref
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "ref" );
+		ma->setType( daeAtomicType::get("xsNCName"));
+		ma->setOffset( daeOffsetOf( domFx_setparam_common , attrRef ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domFx_setparam_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domFx_setparam_common::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_stenciltarget_common.cpp

@@ -0,0 +1,81 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_stenciltarget_common.h>
+
+daeElementRef
+domFx_stenciltarget_common::create(daeInt bytes)
+{
+	domFx_stenciltarget_commonRef ref = new(bytes) domFx_stenciltarget_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_stenciltarget_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_stenciltarget_common" );
+	_Meta->setStaticPointerAddress(&domFx_stenciltarget_common::_Meta);
+	_Meta->registerConstructor(domFx_stenciltarget_common::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("xsNonNegativeInteger"));
+		ma->setOffset( daeOffsetOf( domFx_stenciltarget_common , attrIndex ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "0");
+		ma->setIsRequired( false );
+	
+		_Meta->appendAttribute(ma);
+	}
+
+	//	Add attribute: slice
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "slice" );
+		ma->setType( daeAtomicType::get("xsNonNegativeInteger"));
+		ma->setOffset( daeOffsetOf( domFx_stenciltarget_common , attrSlice ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "0");
+		ma->setIsRequired( false );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domFx_stenciltarget_common));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domFx_stenciltarget_common::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domFx_surface_common.cpp

@@ -0,0 +1,320 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domFx_surface_common.h>
+
+daeElementRef
+domFx_surface_common::create(daeInt bytes)
+{
+	domFx_surface_commonRef ref = new(bytes) domFx_surface_common;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_surface_common::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "fx_surface_common" );
+	_Meta->setStaticPointerAddress(&domFx_surface_common::_Meta);
+	_Meta->registerConstructor(domFx_surface_common::create);
+
+	// Add elements: init_from, format, size, viewport_ratio, mip_levels, mipmap_generate
+    _Meta->appendArrayElement(domFx_surface_common::domInit_from::registerElement(),daeOffsetOf(domFx_surface_common,elemInit_from_array));
+    _Meta->appendElement(domFx_surface_common::domFormat::registerElement(),daeOffsetOf(domFx_surface_common,elemFormat));
+    _Meta->appendElement(domFx_surface_common::domSize::registerElement(),daeOffsetOf(domFx_surface_common,elemSize));
+    _Meta->appendElement(domFx_surface_common::domViewport_ratio::registerElement(),daeOffsetOf(domFx_surface_common,elemViewport_ratio));
+    _Meta->appendElement(domFx_surface_common::domMip_levels::registerElement(),daeOffsetOf(domFx_surface_common,elemMip_levels));
+    _Meta->appendElement(domFx_surface_common::domMipmap_generate::registerElement(),daeOffsetOf(domFx_surface_common,elemMipmap_generate));
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domFx_surface_common,_contents));
+
+
+	//	Add attribute: type
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "type" );
+		ma->setType( daeAtomicType::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::domInit_from::create(daeInt bytes)
+{
+	domFx_surface_common::domInit_fromRef ref = new(bytes) domFx_surface_common::domInit_from;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_surface_common::domInit_from::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "init_from" );
+	_Meta->setStaticPointerAddress(&domFx_surface_common::domInit_from::_Meta);
+	_Meta->registerConstructor(domFx_surface_common::domInit_from::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::get("xsIDREFS"));
+		ma->setOffset( daeOffsetOf( domFx_surface_common::domInit_from , _value ));
+		ma->setContainer( _Meta );
+		_Meta->appendAttribute(ma);
+	}
+
+	//	Add attribute: mip
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "mip" );
+		ma->setType( daeAtomicType::get("xsUnsignedInt"));
+		ma->setOffset( daeOffsetOf( domFx_surface_common::domInit_from , attrMip ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "0");
+	
+		_Meta->appendAttribute(ma);
+	}
+
+	//	Add attribute: slice
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "slice" );
+		ma->setType( daeAtomicType::get("xsUnsignedInt"));
+		ma->setOffset( daeOffsetOf( domFx_surface_common::domInit_from , attrSlice ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "0");
+	
+		_Meta->appendAttribute(ma);
+	}
+
+	//	Add attribute: face
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "face" );
+		ma->setType( daeAtomicType::get("Fx_surface_face_enum"));
+		ma->setOffset( daeOffsetOf( domFx_surface_common::domInit_from , attrFace ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "POSITIVE_X");
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domFx_surface_common::domInit_from));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domFx_surface_common::domFormat::create(daeInt bytes)
+{
+	domFx_surface_common::domFormatRef ref = new(bytes) domFx_surface_common::domFormat;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_surface_common::domFormat::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "format" );
+	_Meta->setStaticPointerAddress(&domFx_surface_common::domFormat::_Meta);
+	_Meta->registerConstructor(domFx_surface_common::domFormat::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::get("xsString"));
+		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(daeInt bytes)
+{
+	domFx_surface_common::domSizeRef ref = new(bytes) domFx_surface_common::domSize;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_surface_common::domSize::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "size" );
+	_Meta->setStaticPointerAddress(&domFx_surface_common::domSize::_Meta);
+	_Meta->registerConstructor(domFx_surface_common::domSize::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_surface_common::domViewport_ratioRef ref = new(bytes) domFx_surface_common::domViewport_ratio;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_surface_common::domViewport_ratio::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "viewport_ratio" );
+	_Meta->setStaticPointerAddress(&domFx_surface_common::domViewport_ratio::_Meta);
+	_Meta->registerConstructor(domFx_surface_common::domViewport_ratio::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_surface_common::domMip_levelsRef ref = new(bytes) domFx_surface_common::domMip_levels;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_surface_common::domMip_levels::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mip_levels" );
+	_Meta->setStaticPointerAddress(&domFx_surface_common::domMip_levels::_Meta);
+	_Meta->registerConstructor(domFx_surface_common::domMip_levels::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domFx_surface_common::domMipmap_generateRef ref = new(bytes) domFx_surface_common::domMipmap_generate;
+	return ref;
+}
+
+
+daeMetaElement *
+domFx_surface_common::domMipmap_generate::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipmap_generate" );
+	_Meta->setStaticPointerAddress(&domFx_surface_common::domMipmap_generate::_Meta);
+	_Meta->registerConstructor(domFx_surface_common::domMipmap_generate::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domFx_surface_common::_Meta = NULL;
+daeMetaElement * domFx_surface_common::domInit_from::_Meta = NULL;
+daeMetaElement * domFx_surface_common::domFormat::_Meta = NULL;
+daeMetaElement * domFx_surface_common::domSize::_Meta = NULL;
+daeMetaElement * domFx_surface_common::domViewport_ratio::_Meta = NULL;
+daeMetaElement * domFx_surface_common::domMip_levels::_Meta = NULL;
+daeMetaElement * domFx_surface_common::domMipmap_generate::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGeometry.cpp

@@ -0,0 +1,77 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGeometry.h>
+
+daeElementRef
+domGeometry::create(daeInt bytes)
+{
+	domGeometryRef ref = new(bytes) domGeometry;
+	return ref;
+}
+
+
+daeMetaElement *
+domGeometry::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "geometry" );
+	_Meta->setStaticPointerAddress(&domGeometry::_Meta);
+	_Meta->registerConstructor(domGeometry::create);
+
+	// Add elements: asset, convex_mesh, mesh, spline, extra
+    _Meta->appendElement(domAsset::registerElement(),daeOffsetOf(domGeometry,elemAsset));
+    _Meta->appendElement(domConvex_mesh::registerElement(),daeOffsetOf(domGeometry,elemConvex_mesh));
+    _Meta->appendElement(domMesh::registerElement(),daeOffsetOf(domGeometry,elemMesh));
+    _Meta->appendElement(domSpline::registerElement(),daeOffsetOf(domGeometry,elemSpline));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domGeometry,elemExtra_array));
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domGeometry,_contents));
+
+
+	//	Add attribute: id
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "id" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("xsNCName"));
+		ma->setOffset( daeOffsetOf( domGeometry , attrName ));
+		ma->setContainer( _Meta );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domGeometry));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domGeometry::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGl_hook_abstract.cpp

@@ -0,0 +1,47 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGl_hook_abstract.h>
+
+daeElementRef
+domGl_hook_abstract::create(daeInt bytes)
+{
+	domGl_hook_abstractRef ref = new(bytes) domGl_hook_abstract;
+	return ref;
+}
+
+
+daeMetaElement *
+domGl_hook_abstract::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gl_hook_abstract" );
+	_Meta->setStaticPointerAddress(&domGl_hook_abstract::_Meta);
+	_Meta->registerConstructor(domGl_hook_abstract::create);
+
+	_Meta->setIsAbstract( true );
+	
+	
+	_Meta->setElementSize(sizeof(domGl_hook_abstract));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domGl_hook_abstract::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGl_sampler1D.cpp

@@ -0,0 +1,55 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGl_sampler1D.h>
+
+daeElementRef
+domGl_sampler1D::create(daeInt bytes)
+{
+	domGl_sampler1DRef ref = new(bytes) domGl_sampler1D;
+	return ref;
+}
+
+
+daeMetaElement *
+domGl_sampler1D::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gl_sampler1D" );
+	_Meta->setStaticPointerAddress(&domGl_sampler1D::_Meta);
+	_Meta->registerConstructor(domGl_sampler1D::create);
+
+	// Add elements: source, wrap_s, minfilter, magfilter, mipfilter, border_color, mipmap_maxlevel, mipmap_bias
+    _Meta->appendElement(domSource::registerElement(),daeOffsetOf(domGl_sampler1D,elemSource));
+    _Meta->appendElement(domWrap_s::registerElement(),daeOffsetOf(domGl_sampler1D,elemWrap_s));
+    _Meta->appendElement(domMinfilter::registerElement(),daeOffsetOf(domGl_sampler1D,elemMinfilter));
+    _Meta->appendElement(domMagfilter::registerElement(),daeOffsetOf(domGl_sampler1D,elemMagfilter));
+    _Meta->appendElement(domMipfilter::registerElement(),daeOffsetOf(domGl_sampler1D,elemMipfilter));
+    _Meta->appendElement(domBorder_color::registerElement(),daeOffsetOf(domGl_sampler1D,elemBorder_color));
+    _Meta->appendElement(domMipmap_maxlevel::registerElement(),daeOffsetOf(domGl_sampler1D,elemMipmap_maxlevel));
+    _Meta->appendElement(domMipmap_bias::registerElement(),daeOffsetOf(domGl_sampler1D,elemMipmap_bias));
+	
+	
+	_Meta->setElementSize(sizeof(domGl_sampler1D));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domGl_sampler1D::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGl_sampler2D.cpp

@@ -0,0 +1,56 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGl_sampler2D.h>
+
+daeElementRef
+domGl_sampler2D::create(daeInt bytes)
+{
+	domGl_sampler2DRef ref = new(bytes) domGl_sampler2D;
+	return ref;
+}
+
+
+daeMetaElement *
+domGl_sampler2D::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gl_sampler2D" );
+	_Meta->setStaticPointerAddress(&domGl_sampler2D::_Meta);
+	_Meta->registerConstructor(domGl_sampler2D::create);
+
+	// Add elements: source, wrap_s, wrap_t, minfilter, magfilter, mipfilter, border_color, mipmap_maxlevel, mipmap_bias
+    _Meta->appendElement(domSource::registerElement(),daeOffsetOf(domGl_sampler2D,elemSource));
+    _Meta->appendElement(domWrap_s::registerElement(),daeOffsetOf(domGl_sampler2D,elemWrap_s));
+    _Meta->appendElement(domWrap_t::registerElement(),daeOffsetOf(domGl_sampler2D,elemWrap_t));
+    _Meta->appendElement(domMinfilter::registerElement(),daeOffsetOf(domGl_sampler2D,elemMinfilter));
+    _Meta->appendElement(domMagfilter::registerElement(),daeOffsetOf(domGl_sampler2D,elemMagfilter));
+    _Meta->appendElement(domMipfilter::registerElement(),daeOffsetOf(domGl_sampler2D,elemMipfilter));
+    _Meta->appendElement(domBorder_color::registerElement(),daeOffsetOf(domGl_sampler2D,elemBorder_color));
+    _Meta->appendElement(domMipmap_maxlevel::registerElement(),daeOffsetOf(domGl_sampler2D,elemMipmap_maxlevel));
+    _Meta->appendElement(domMipmap_bias::registerElement(),daeOffsetOf(domGl_sampler2D,elemMipmap_bias));
+	
+	
+	_Meta->setElementSize(sizeof(domGl_sampler2D));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domGl_sampler2D::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGl_sampler3D.cpp

@@ -0,0 +1,57 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGl_sampler3D.h>
+
+daeElementRef
+domGl_sampler3D::create(daeInt bytes)
+{
+	domGl_sampler3DRef ref = new(bytes) domGl_sampler3D;
+	return ref;
+}
+
+
+daeMetaElement *
+domGl_sampler3D::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gl_sampler3D" );
+	_Meta->setStaticPointerAddress(&domGl_sampler3D::_Meta);
+	_Meta->registerConstructor(domGl_sampler3D::create);
+
+	// Add elements: source, wrap_s, wrap_t, wrap_p, minfilter, magfilter, mipfilter, border_color, mipmap_maxlevel, mipmap_bias
+    _Meta->appendElement(domSource::registerElement(),daeOffsetOf(domGl_sampler3D,elemSource));
+    _Meta->appendElement(domWrap_s::registerElement(),daeOffsetOf(domGl_sampler3D,elemWrap_s));
+    _Meta->appendElement(domWrap_t::registerElement(),daeOffsetOf(domGl_sampler3D,elemWrap_t));
+    _Meta->appendElement(domWrap_p::registerElement(),daeOffsetOf(domGl_sampler3D,elemWrap_p));
+    _Meta->appendElement(domMinfilter::registerElement(),daeOffsetOf(domGl_sampler3D,elemMinfilter));
+    _Meta->appendElement(domMagfilter::registerElement(),daeOffsetOf(domGl_sampler3D,elemMagfilter));
+    _Meta->appendElement(domMipfilter::registerElement(),daeOffsetOf(domGl_sampler3D,elemMipfilter));
+    _Meta->appendElement(domBorder_color::registerElement(),daeOffsetOf(domGl_sampler3D,elemBorder_color));
+    _Meta->appendElement(domMipmap_maxlevel::registerElement(),daeOffsetOf(domGl_sampler3D,elemMipmap_maxlevel));
+    _Meta->appendElement(domMipmap_bias::registerElement(),daeOffsetOf(domGl_sampler3D,elemMipmap_bias));
+	
+	
+	_Meta->setElementSize(sizeof(domGl_sampler3D));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domGl_sampler3D::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGl_samplerCUBE.cpp

@@ -0,0 +1,57 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGl_samplerCUBE.h>
+
+daeElementRef
+domGl_samplerCUBE::create(daeInt bytes)
+{
+	domGl_samplerCUBERef ref = new(bytes) domGl_samplerCUBE;
+	return ref;
+}
+
+
+daeMetaElement *
+domGl_samplerCUBE::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gl_samplerCUBE" );
+	_Meta->setStaticPointerAddress(&domGl_samplerCUBE::_Meta);
+	_Meta->registerConstructor(domGl_samplerCUBE::create);
+
+	// Add elements: source, wrap_s, wrap_t, wrap_p, minfilter, magfilter, mipfilter, border_color, mipmap_maxlevel, mipmap_bias
+    _Meta->appendElement(domSource::registerElement(),daeOffsetOf(domGl_samplerCUBE,elemSource));
+    _Meta->appendElement(domWrap_s::registerElement(),daeOffsetOf(domGl_samplerCUBE,elemWrap_s));
+    _Meta->appendElement(domWrap_t::registerElement(),daeOffsetOf(domGl_samplerCUBE,elemWrap_t));
+    _Meta->appendElement(domWrap_p::registerElement(),daeOffsetOf(domGl_samplerCUBE,elemWrap_p));
+    _Meta->appendElement(domMinfilter::registerElement(),daeOffsetOf(domGl_samplerCUBE,elemMinfilter));
+    _Meta->appendElement(domMagfilter::registerElement(),daeOffsetOf(domGl_samplerCUBE,elemMagfilter));
+    _Meta->appendElement(domMipfilter::registerElement(),daeOffsetOf(domGl_samplerCUBE,elemMipfilter));
+    _Meta->appendElement(domBorder_color::registerElement(),daeOffsetOf(domGl_samplerCUBE,elemBorder_color));
+    _Meta->appendElement(domMipmap_maxlevel::registerElement(),daeOffsetOf(domGl_samplerCUBE,elemMipmap_maxlevel));
+    _Meta->appendElement(domMipmap_bias::registerElement(),daeOffsetOf(domGl_samplerCUBE,elemMipmap_bias));
+	
+	
+	_Meta->setElementSize(sizeof(domGl_samplerCUBE));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domGl_samplerCUBE::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGl_samplerDEPTH.cpp

@@ -0,0 +1,52 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGl_samplerDEPTH.h>
+
+daeElementRef
+domGl_samplerDEPTH::create(daeInt bytes)
+{
+	domGl_samplerDEPTHRef ref = new(bytes) domGl_samplerDEPTH;
+	return ref;
+}
+
+
+daeMetaElement *
+domGl_samplerDEPTH::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gl_samplerDEPTH" );
+	_Meta->setStaticPointerAddress(&domGl_samplerDEPTH::_Meta);
+	_Meta->registerConstructor(domGl_samplerDEPTH::create);
+
+	// Add elements: source, wrap_s, wrap_t, minfilter, magfilter
+    _Meta->appendElement(domSource::registerElement(),daeOffsetOf(domGl_samplerDEPTH,elemSource));
+    _Meta->appendElement(domWrap_s::registerElement(),daeOffsetOf(domGl_samplerDEPTH,elemWrap_s));
+    _Meta->appendElement(domWrap_t::registerElement(),daeOffsetOf(domGl_samplerDEPTH,elemWrap_t));
+    _Meta->appendElement(domMinfilter::registerElement(),daeOffsetOf(domGl_samplerDEPTH,elemMinfilter));
+    _Meta->appendElement(domMagfilter::registerElement(),daeOffsetOf(domGl_samplerDEPTH,elemMagfilter));
+	
+	
+	_Meta->setElementSize(sizeof(domGl_samplerDEPTH));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domGl_samplerDEPTH::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGl_samplerRECT.cpp

@@ -0,0 +1,56 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGl_samplerRECT.h>
+
+daeElementRef
+domGl_samplerRECT::create(daeInt bytes)
+{
+	domGl_samplerRECTRef ref = new(bytes) domGl_samplerRECT;
+	return ref;
+}
+
+
+daeMetaElement *
+domGl_samplerRECT::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gl_samplerRECT" );
+	_Meta->setStaticPointerAddress(&domGl_samplerRECT::_Meta);
+	_Meta->registerConstructor(domGl_samplerRECT::create);
+
+	// Add elements: source, wrap_s, wrap_t, minfilter, magfilter, mipfilter, border_color, mipmap_maxlevel, mipmap_bias
+    _Meta->appendElement(domSource::registerElement(),daeOffsetOf(domGl_samplerRECT,elemSource));
+    _Meta->appendElement(domWrap_s::registerElement(),daeOffsetOf(domGl_samplerRECT,elemWrap_s));
+    _Meta->appendElement(domWrap_t::registerElement(),daeOffsetOf(domGl_samplerRECT,elemWrap_t));
+    _Meta->appendElement(domMinfilter::registerElement(),daeOffsetOf(domGl_samplerRECT,elemMinfilter));
+    _Meta->appendElement(domMagfilter::registerElement(),daeOffsetOf(domGl_samplerRECT,elemMagfilter));
+    _Meta->appendElement(domMipfilter::registerElement(),daeOffsetOf(domGl_samplerRECT,elemMipfilter));
+    _Meta->appendElement(domBorder_color::registerElement(),daeOffsetOf(domGl_samplerRECT,elemBorder_color));
+    _Meta->appendElement(domMipmap_maxlevel::registerElement(),daeOffsetOf(domGl_samplerRECT,elemMipmap_maxlevel));
+    _Meta->appendElement(domMipmap_bias::registerElement(),daeOffsetOf(domGl_samplerRECT,elemMipmap_bias));
+	
+	
+	_Meta->setElementSize(sizeof(domGl_samplerRECT));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domGl_samplerRECT::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGles_newparam.cpp

@@ -0,0 +1,168 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGles_newparam.h>
+
+daeElementRef
+domGles_newparam::create(daeInt bytes)
+{
+	domGles_newparamRef ref = new(bytes) domGles_newparam;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_newparam::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gles_newparam" );
+	_Meta->setStaticPointerAddress(&domGles_newparam::_Meta);
+	_Meta->registerConstructor(domGles_newparam::create);
+
+	// Add elements: annotate, semantic, modifier, gles_basic_type_common
+    _Meta->appendArrayElement(domFx_annotate_common::registerElement(),daeOffsetOf(domGles_newparam,elemAnnotate_array),"annotate"); 
+    _Meta->appendElement(domGles_newparam::domSemantic::registerElement(),daeOffsetOf(domGles_newparam,elemSemantic));
+    _Meta->appendElement(domGles_newparam::domModifier::registerElement(),daeOffsetOf(domGles_newparam,elemModifier));
+    _Meta->appendElement(domGles_basic_type_common::registerElement(),daeOffsetOf(domGles_newparam,elemGles_basic_type_common));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float1x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float1x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float1x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float1x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4x1", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "surface", _Meta->getMetaElements()[3], "fx_surface_common");
+	_Meta->appendPossibleChild( "texture_pipeline", _Meta->getMetaElements()[3], "gles_texture_pipeline");
+	_Meta->appendPossibleChild( "sampler_state", _Meta->getMetaElements()[3], "gles_sampler_state");
+	_Meta->appendPossibleChild( "texture_unit", _Meta->getMetaElements()[3], "gles_texture_unit");
+	_Meta->appendPossibleChild( "enum", _Meta->getMetaElements()[3]);
+
+	//	Add attribute: sid
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "sid" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGles_newparam::domSemanticRef ref = new(bytes) domGles_newparam::domSemantic;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_newparam::domSemantic::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "semantic" );
+	_Meta->setStaticPointerAddress(&domGles_newparam::domSemantic::_Meta);
+	_Meta->registerConstructor(domGles_newparam::domSemantic::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGles_newparam::domModifierRef ref = new(bytes) domGles_newparam::domModifier;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_newparam::domModifier::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "modifier" );
+	_Meta->setStaticPointerAddress(&domGles_newparam::domModifier::_Meta);
+	_Meta->registerConstructor(domGles_newparam::domModifier::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGles_newparam::_Meta = NULL;
+daeMetaElement * domGles_newparam::domSemantic::_Meta = NULL;
+daeMetaElement * domGles_newparam::domModifier::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGles_sampler_state.cpp

@@ -0,0 +1,318 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGles_sampler_state.h>
+
+daeElementRef
+domGles_sampler_state::create(daeInt bytes)
+{
+	domGles_sampler_stateRef ref = new(bytes) domGles_sampler_state;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_sampler_state::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gles_sampler_state" );
+	_Meta->setStaticPointerAddress(&domGles_sampler_state::_Meta);
+	_Meta->registerConstructor(domGles_sampler_state::create);
+
+	// Add elements: wrap_s, wrap_t, minfilter, magfilter, mipfilter, mipmap_maxlevel, mipmap_bias, extra
+    _Meta->appendElement(domGles_sampler_state::domWrap_s::registerElement(),daeOffsetOf(domGles_sampler_state,elemWrap_s));
+    _Meta->appendElement(domGles_sampler_state::domWrap_t::registerElement(),daeOffsetOf(domGles_sampler_state,elemWrap_t));
+    _Meta->appendElement(domGles_sampler_state::domMinfilter::registerElement(),daeOffsetOf(domGles_sampler_state,elemMinfilter));
+    _Meta->appendElement(domGles_sampler_state::domMagfilter::registerElement(),daeOffsetOf(domGles_sampler_state,elemMagfilter));
+    _Meta->appendElement(domGles_sampler_state::domMipfilter::registerElement(),daeOffsetOf(domGles_sampler_state,elemMipfilter));
+    _Meta->appendElement(domGles_sampler_state::domMipmap_maxlevel::registerElement(),daeOffsetOf(domGles_sampler_state,elemMipmap_maxlevel));
+    _Meta->appendElement(domGles_sampler_state::domMipmap_bias::registerElement(),daeOffsetOf(domGles_sampler_state,elemMipmap_bias));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domGles_sampler_state,elemExtra_array));
+
+	//	Add attribute: sid
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "sid" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGles_sampler_state::domWrap_sRef ref = new(bytes) domGles_sampler_state::domWrap_s;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_sampler_state::domWrap_s::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "wrap_s" );
+	_Meta->setStaticPointerAddress(&domGles_sampler_state::domWrap_s::_Meta);
+	_Meta->registerConstructor(domGles_sampler_state::domWrap_s::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGles_sampler_state::domWrap_tRef ref = new(bytes) domGles_sampler_state::domWrap_t;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_sampler_state::domWrap_t::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "wrap_t" );
+	_Meta->setStaticPointerAddress(&domGles_sampler_state::domWrap_t::_Meta);
+	_Meta->registerConstructor(domGles_sampler_state::domWrap_t::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGles_sampler_state::domMinfilterRef ref = new(bytes) domGles_sampler_state::domMinfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_sampler_state::domMinfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "minfilter" );
+	_Meta->setStaticPointerAddress(&domGles_sampler_state::domMinfilter::_Meta);
+	_Meta->registerConstructor(domGles_sampler_state::domMinfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGles_sampler_state::domMagfilterRef ref = new(bytes) domGles_sampler_state::domMagfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_sampler_state::domMagfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "magfilter" );
+	_Meta->setStaticPointerAddress(&domGles_sampler_state::domMagfilter::_Meta);
+	_Meta->registerConstructor(domGles_sampler_state::domMagfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGles_sampler_state::domMipfilterRef ref = new(bytes) domGles_sampler_state::domMipfilter;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_sampler_state::domMipfilter::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipfilter" );
+	_Meta->setStaticPointerAddress(&domGles_sampler_state::domMipfilter::_Meta);
+	_Meta->registerConstructor(domGles_sampler_state::domMipfilter::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGles_sampler_state::domMipmap_maxlevelRef ref = new(bytes) domGles_sampler_state::domMipmap_maxlevel;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_sampler_state::domMipmap_maxlevel::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipmap_maxlevel" );
+	_Meta->setStaticPointerAddress(&domGles_sampler_state::domMipmap_maxlevel::_Meta);
+	_Meta->registerConstructor(domGles_sampler_state::domMipmap_maxlevel::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGles_sampler_state::domMipmap_biasRef ref = new(bytes) domGles_sampler_state::domMipmap_bias;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_sampler_state::domMipmap_bias::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "mipmap_bias" );
+	_Meta->setStaticPointerAddress(&domGles_sampler_state::domMipmap_bias::_Meta);
+	_Meta->registerConstructor(domGles_sampler_state::domMipmap_bias::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGles_sampler_state::_Meta = NULL;
+daeMetaElement * domGles_sampler_state::domWrap_s::_Meta = NULL;
+daeMetaElement * domGles_sampler_state::domWrap_t::_Meta = NULL;
+daeMetaElement * domGles_sampler_state::domMinfilter::_Meta = NULL;
+daeMetaElement * domGles_sampler_state::domMagfilter::_Meta = NULL;
+daeMetaElement * domGles_sampler_state::domMipfilter::_Meta = NULL;
+daeMetaElement * domGles_sampler_state::domMipmap_maxlevel::_Meta = NULL;
+daeMetaElement * domGles_sampler_state::domMipmap_bias::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGles_texcombiner_argumentAlpha_type.cpp

@@ -0,0 +1,81 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGles_texcombiner_argumentAlpha_type.h>
+
+daeElementRef
+domGles_texcombiner_argumentAlpha_type::create(daeInt bytes)
+{
+	domGles_texcombiner_argumentAlpha_typeRef ref = new(bytes) domGles_texcombiner_argumentAlpha_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_texcombiner_argumentAlpha_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gles_texcombiner_argumentAlpha_type" );
+	_Meta->setStaticPointerAddress(&domGles_texcombiner_argumentAlpha_type::_Meta);
+	_Meta->registerConstructor(domGles_texcombiner_argumentAlpha_type::create);
+
+
+	//	Add attribute: source
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "source" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("Gles_texcombiner_operandAlpha_enums"));
+		ma->setOffset( daeOffsetOf( domGles_texcombiner_argumentAlpha_type , attrOperand ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "SRC_ALPHA");
+	
+		_Meta->appendAttribute(ma);
+	}
+
+	//	Add attribute: unit
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "unit" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGles_texcombiner_argumentAlpha_type::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGles_texcombiner_argumentRGB_type.cpp

@@ -0,0 +1,81 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGles_texcombiner_argumentRGB_type.h>
+
+daeElementRef
+domGles_texcombiner_argumentRGB_type::create(daeInt bytes)
+{
+	domGles_texcombiner_argumentRGB_typeRef ref = new(bytes) domGles_texcombiner_argumentRGB_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_texcombiner_argumentRGB_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gles_texcombiner_argumentRGB_type" );
+	_Meta->setStaticPointerAddress(&domGles_texcombiner_argumentRGB_type::_Meta);
+	_Meta->registerConstructor(domGles_texcombiner_argumentRGB_type::create);
+
+
+	//	Add attribute: source
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "source" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("Gles_texcombiner_operandRGB_enums"));
+		ma->setOffset( daeOffsetOf( domGles_texcombiner_argumentRGB_type , attrOperand ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "SRC_COLOR");
+	
+		_Meta->appendAttribute(ma);
+	}
+
+	//	Add attribute: unit
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "unit" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGles_texcombiner_argumentRGB_type::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGles_texcombiner_commandAlpha_type.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/daeDom.h>
+#include <dom/domGles_texcombiner_commandAlpha_type.h>
+
+daeElementRef
+domGles_texcombiner_commandAlpha_type::create(daeInt bytes)
+{
+	domGles_texcombiner_commandAlpha_typeRef ref = new(bytes) domGles_texcombiner_commandAlpha_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_texcombiner_commandAlpha_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gles_texcombiner_commandAlpha_type" );
+	_Meta->setStaticPointerAddress(&domGles_texcombiner_commandAlpha_type::_Meta);
+	_Meta->registerConstructor(domGles_texcombiner_commandAlpha_type::create);
+
+	// Add elements: argument
+    _Meta->appendArrayElement(domGles_texcombiner_argumentAlpha_type::registerElement(),daeOffsetOf(domGles_texcombiner_commandAlpha_type,elemArgument_array),"argument"); 
+
+	//	Add attribute: operator
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "operator" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGles_texcombiner_commandAlpha_type::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGles_texcombiner_commandRGB_type.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/daeDom.h>
+#include <dom/domGles_texcombiner_commandRGB_type.h>
+
+daeElementRef
+domGles_texcombiner_commandRGB_type::create(daeInt bytes)
+{
+	domGles_texcombiner_commandRGB_typeRef ref = new(bytes) domGles_texcombiner_commandRGB_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_texcombiner_commandRGB_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gles_texcombiner_commandRGB_type" );
+	_Meta->setStaticPointerAddress(&domGles_texcombiner_commandRGB_type::_Meta);
+	_Meta->registerConstructor(domGles_texcombiner_commandRGB_type::create);
+
+	// Add elements: argument
+    _Meta->appendArrayElement(domGles_texcombiner_argumentRGB_type::registerElement(),daeOffsetOf(domGles_texcombiner_commandRGB_type,elemArgument_array),"argument"); 
+
+	//	Add attribute: operator
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "operator" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGles_texcombiner_commandRGB_type::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGles_texcombiner_command_type.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/daeDom.h>
+#include <dom/domGles_texcombiner_command_type.h>
+
+daeElementRef
+domGles_texcombiner_command_type::create(daeInt bytes)
+{
+	domGles_texcombiner_command_typeRef ref = new(bytes) domGles_texcombiner_command_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_texcombiner_command_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gles_texcombiner_command_type" );
+	_Meta->setStaticPointerAddress(&domGles_texcombiner_command_type::_Meta);
+	_Meta->registerConstructor(domGles_texcombiner_command_type::create);
+
+	// Add elements: constant, RGB, alpha
+    _Meta->appendElement(domGles_texture_constant_type::registerElement(),daeOffsetOf(domGles_texcombiner_command_type,elemConstant),"constant"); 
+    _Meta->appendElement(domGles_texcombiner_commandRGB_type::registerElement(),daeOffsetOf(domGles_texcombiner_command_type,elemRGB),"RGB"); 
+    _Meta->appendElement(domGles_texcombiner_commandAlpha_type::registerElement(),daeOffsetOf(domGles_texcombiner_command_type,elemAlpha),"alpha"); 
+	
+	
+	_Meta->setElementSize(sizeof(domGles_texcombiner_command_type));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domGles_texcombiner_command_type::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGles_texenv_command_type.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/daeDom.h>
+#include <dom/domGles_texenv_command_type.h>
+
+daeElementRef
+domGles_texenv_command_type::create(daeInt bytes)
+{
+	domGles_texenv_command_typeRef ref = new(bytes) domGles_texenv_command_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_texenv_command_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gles_texenv_command_type" );
+	_Meta->setStaticPointerAddress(&domGles_texenv_command_type::_Meta);
+	_Meta->registerConstructor(domGles_texenv_command_type::create);
+
+	// Add elements: constant
+    _Meta->appendElement(domGles_texture_constant_type::registerElement(),daeOffsetOf(domGles_texenv_command_type,elemConstant),"constant"); 
+
+	//	Add attribute: operator
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "operator" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGles_texenv_command_type::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGles_texture_constant_type.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/daeDom.h>
+#include <dom/domGles_texture_constant_type.h>
+
+daeElementRef
+domGles_texture_constant_type::create(daeInt bytes)
+{
+	domGles_texture_constant_typeRef ref = new(bytes) domGles_texture_constant_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_texture_constant_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gles_texture_constant_type" );
+	_Meta->setStaticPointerAddress(&domGles_texture_constant_type::_Meta);
+	_Meta->registerConstructor(domGles_texture_constant_type::create);
+
+
+	//	Add attribute: value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "value" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGles_texture_constant_type::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGles_texture_pipeline.cpp

@@ -0,0 +1,64 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGles_texture_pipeline.h>
+
+daeElementRef
+domGles_texture_pipeline::create(daeInt bytes)
+{
+	domGles_texture_pipelineRef ref = new(bytes) domGles_texture_pipeline;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_texture_pipeline::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gles_texture_pipeline" );
+	_Meta->setStaticPointerAddress(&domGles_texture_pipeline::_Meta);
+	_Meta->registerConstructor(domGles_texture_pipeline::create);
+
+	// Add elements: texcombiner, texenv, extra
+    _Meta->appendArrayElement(domGles_texcombiner_command_type::registerElement(),daeOffsetOf(domGles_texture_pipeline,elemTexcombiner_array),"texcombiner"); 
+    _Meta->appendArrayElement(domGles_texenv_command_type::registerElement(),daeOffsetOf(domGles_texture_pipeline,elemTexenv_array),"texenv"); 
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domGles_texture_pipeline,elemExtra_array));
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domGles_texture_pipeline,_contents));
+
+
+	//	Add attribute: sid
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "sid" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGles_texture_pipeline::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGles_texture_unit.cpp

@@ -0,0 +1,171 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGles_texture_unit.h>
+
+daeElementRef
+domGles_texture_unit::create(daeInt bytes)
+{
+	domGles_texture_unitRef ref = new(bytes) domGles_texture_unit;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_texture_unit::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "gles_texture_unit" );
+	_Meta->setStaticPointerAddress(&domGles_texture_unit::_Meta);
+	_Meta->registerConstructor(domGles_texture_unit::create);
+
+	// Add elements: surface, sampler_state, texcoord
+    _Meta->appendElement(domGles_texture_unit::domSurface::registerElement(),daeOffsetOf(domGles_texture_unit,elemSurface));
+    _Meta->appendElement(domGles_texture_unit::domSampler_state::registerElement(),daeOffsetOf(domGles_texture_unit,elemSampler_state));
+    _Meta->appendElement(domGles_texture_unit::domTexcoord::registerElement(),daeOffsetOf(domGles_texture_unit,elemTexcoord));
+
+	//	Add attribute: sid
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "sid" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGles_texture_unit::domSurfaceRef ref = new(bytes) domGles_texture_unit::domSurface;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_texture_unit::domSurface::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "surface" );
+	_Meta->setStaticPointerAddress(&domGles_texture_unit::domSurface::_Meta);
+	_Meta->registerConstructor(domGles_texture_unit::domSurface::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGles_texture_unit::domSampler_stateRef ref = new(bytes) domGles_texture_unit::domSampler_state;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_texture_unit::domSampler_state::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "sampler_state" );
+	_Meta->setStaticPointerAddress(&domGles_texture_unit::domSampler_state::_Meta);
+	_Meta->registerConstructor(domGles_texture_unit::domSampler_state::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGles_texture_unit::domTexcoordRef ref = new(bytes) domGles_texture_unit::domTexcoord;
+	return ref;
+}
+
+
+daeMetaElement *
+domGles_texture_unit::domTexcoord::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "texcoord" );
+	_Meta->setStaticPointerAddress(&domGles_texture_unit::domTexcoord::_Meta);
+	_Meta->registerConstructor(domGles_texture_unit::domTexcoord::create);
+
+
+	//	Add attribute: semantic
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "semantic" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGles_texture_unit::_Meta = NULL;
+daeMetaElement * domGles_texture_unit::domSurface::_Meta = NULL;
+daeMetaElement * domGles_texture_unit::domSampler_state::_Meta = NULL;
+daeMetaElement * domGles_texture_unit::domTexcoord::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGlsl_newarray_type.cpp

@@ -0,0 +1,87 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGlsl_newarray_type.h>
+
+daeElementRef
+domGlsl_newarray_type::create(daeInt bytes)
+{
+	domGlsl_newarray_typeRef ref = new(bytes) domGlsl_newarray_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_newarray_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "glsl_newarray_type" );
+	_Meta->setStaticPointerAddress(&domGlsl_newarray_type::_Meta);
+	_Meta->registerConstructor(domGlsl_newarray_type::create);
+
+	// Add elements: glsl_param_type, array
+    _Meta->appendArrayElement(domGlsl_param_type::registerElement(),daeOffsetOf(domGlsl_newarray_type,elemGlsl_param_type_array));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "surface", _Meta->getMetaElements()[0], "fx_surface_common");
+	_Meta->appendPossibleChild( "sampler1D", _Meta->getMetaElements()[0], "gl_sampler1D");
+	_Meta->appendPossibleChild( "sampler2D", _Meta->getMetaElements()[0], "gl_sampler2D");
+	_Meta->appendPossibleChild( "sampler3D", _Meta->getMetaElements()[0], "gl_sampler3D");
+	_Meta->appendPossibleChild( "samplerCUBE", _Meta->getMetaElements()[0], "gl_samplerCUBE");
+	_Meta->appendPossibleChild( "samplerRECT", _Meta->getMetaElements()[0], "gl_samplerRECT");
+	_Meta->appendPossibleChild( "samplerDEPTH", _Meta->getMetaElements()[0], "gl_samplerDEPTH");
+	_Meta->appendPossibleChild( "enum", _Meta->getMetaElements()[0]);
+    _Meta->appendArrayElement(domGlsl_newarray_type::registerElement(),daeOffsetOf(domGlsl_newarray_type,elemArray_array),"array"); 
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domGlsl_newarray_type,_contents));
+
+
+	//	Add attribute: length
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "length" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGlsl_newarray_type::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGlsl_newparam.cpp

@@ -0,0 +1,162 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGlsl_newparam.h>
+
+daeElementRef
+domGlsl_newparam::create(daeInt bytes)
+{
+	domGlsl_newparamRef ref = new(bytes) domGlsl_newparam;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_newparam::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "glsl_newparam" );
+	_Meta->setStaticPointerAddress(&domGlsl_newparam::_Meta);
+	_Meta->registerConstructor(domGlsl_newparam::create);
+
+	// Add elements: annotate, semantic, modifier, glsl_param_type, array
+    _Meta->appendArrayElement(domFx_annotate_common::registerElement(),daeOffsetOf(domGlsl_newparam,elemAnnotate_array),"annotate"); 
+    _Meta->appendElement(domGlsl_newparam::domSemantic::registerElement(),daeOffsetOf(domGlsl_newparam,elemSemantic));
+    _Meta->appendElement(domGlsl_newparam::domModifier::registerElement(),daeOffsetOf(domGlsl_newparam,elemModifier));
+    _Meta->appendElement(domGlsl_param_type::registerElement(),daeOffsetOf(domGlsl_newparam,elemGlsl_param_type));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[3]);
+	_Meta->appendPossibleChild( "surface", _Meta->getMetaElements()[3], "fx_surface_common");
+	_Meta->appendPossibleChild( "sampler1D", _Meta->getMetaElements()[3], "gl_sampler1D");
+	_Meta->appendPossibleChild( "sampler2D", _Meta->getMetaElements()[3], "gl_sampler2D");
+	_Meta->appendPossibleChild( "sampler3D", _Meta->getMetaElements()[3], "gl_sampler3D");
+	_Meta->appendPossibleChild( "samplerCUBE", _Meta->getMetaElements()[3], "gl_samplerCUBE");
+	_Meta->appendPossibleChild( "samplerRECT", _Meta->getMetaElements()[3], "gl_samplerRECT");
+	_Meta->appendPossibleChild( "samplerDEPTH", _Meta->getMetaElements()[3], "gl_samplerDEPTH");
+	_Meta->appendPossibleChild( "enum", _Meta->getMetaElements()[3]);
+    _Meta->appendElement(domGlsl_newarray_type::registerElement(),daeOffsetOf(domGlsl_newparam,elemArray),"array"); 
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domGlsl_newparam,_contents));
+
+
+	//	Add attribute: sid
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "sid" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_newparam::domSemanticRef ref = new(bytes) domGlsl_newparam::domSemantic;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_newparam::domSemantic::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "semantic" );
+	_Meta->setStaticPointerAddress(&domGlsl_newparam::domSemantic::_Meta);
+	_Meta->registerConstructor(domGlsl_newparam::domSemantic::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_newparam::domModifierRef ref = new(bytes) domGlsl_newparam::domModifier;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_newparam::domModifier::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "modifier" );
+	_Meta->setStaticPointerAddress(&domGlsl_newparam::domModifier::_Meta);
+	_Meta->registerConstructor(domGlsl_newparam::domModifier::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGlsl_newparam::_Meta = NULL;
+daeMetaElement * domGlsl_newparam::domSemantic::_Meta = NULL;
+daeMetaElement * domGlsl_newparam::domModifier::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGlsl_param_type.cpp

@@ -0,0 +1,650 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGlsl_param_type.h>
+
+daeElementRef
+domGlsl_param_type::create(daeInt bytes)
+{
+	domGlsl_param_typeRef ref = new(bytes) domGlsl_param_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "glsl_param_type" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::create);
+
+	_Meta->setIsTransparent( true );
+	// Add elements: bool, bool2, bool3, bool4, float, float2, float3, float4, float2x2, float3x3, float4x4, int, int2, int3, int4, surface, sampler1D, sampler2D, sampler3D, samplerCUBE, samplerRECT, samplerDEPTH, enum
+    _Meta->appendElement(domGlsl_param_type::domBool::registerElement(),daeOffsetOf(domGlsl_param_type,elemBool));
+    _Meta->appendElement(domGlsl_param_type::domBool2::registerElement(),daeOffsetOf(domGlsl_param_type,elemBool2));
+    _Meta->appendElement(domGlsl_param_type::domBool3::registerElement(),daeOffsetOf(domGlsl_param_type,elemBool3));
+    _Meta->appendElement(domGlsl_param_type::domBool4::registerElement(),daeOffsetOf(domGlsl_param_type,elemBool4));
+    _Meta->appendElement(domGlsl_param_type::domFloat::registerElement(),daeOffsetOf(domGlsl_param_type,elemFloat));
+    _Meta->appendElement(domGlsl_param_type::domFloat2::registerElement(),daeOffsetOf(domGlsl_param_type,elemFloat2));
+    _Meta->appendElement(domGlsl_param_type::domFloat3::registerElement(),daeOffsetOf(domGlsl_param_type,elemFloat3));
+    _Meta->appendElement(domGlsl_param_type::domFloat4::registerElement(),daeOffsetOf(domGlsl_param_type,elemFloat4));
+    _Meta->appendElement(domGlsl_param_type::domFloat2x2::registerElement(),daeOffsetOf(domGlsl_param_type,elemFloat2x2));
+    _Meta->appendElement(domGlsl_param_type::domFloat3x3::registerElement(),daeOffsetOf(domGlsl_param_type,elemFloat3x3));
+    _Meta->appendElement(domGlsl_param_type::domFloat4x4::registerElement(),daeOffsetOf(domGlsl_param_type,elemFloat4x4));
+    _Meta->appendElement(domGlsl_param_type::domInt::registerElement(),daeOffsetOf(domGlsl_param_type,elemInt));
+    _Meta->appendElement(domGlsl_param_type::domInt2::registerElement(),daeOffsetOf(domGlsl_param_type,elemInt2));
+    _Meta->appendElement(domGlsl_param_type::domInt3::registerElement(),daeOffsetOf(domGlsl_param_type,elemInt3));
+    _Meta->appendElement(domGlsl_param_type::domInt4::registerElement(),daeOffsetOf(domGlsl_param_type,elemInt4));
+    _Meta->appendElement(domFx_surface_common::registerElement(),daeOffsetOf(domGlsl_param_type,elemSurface),"surface"); 
+    _Meta->appendElement(domGl_sampler1D::registerElement(),daeOffsetOf(domGlsl_param_type,elemSampler1D),"sampler1D"); 
+    _Meta->appendElement(domGl_sampler2D::registerElement(),daeOffsetOf(domGlsl_param_type,elemSampler2D),"sampler2D"); 
+    _Meta->appendElement(domGl_sampler3D::registerElement(),daeOffsetOf(domGlsl_param_type,elemSampler3D),"sampler3D"); 
+    _Meta->appendElement(domGl_samplerCUBE::registerElement(),daeOffsetOf(domGlsl_param_type,elemSamplerCUBE),"samplerCUBE"); 
+    _Meta->appendElement(domGl_samplerRECT::registerElement(),daeOffsetOf(domGlsl_param_type,elemSamplerRECT),"samplerRECT"); 
+    _Meta->appendElement(domGl_samplerDEPTH::registerElement(),daeOffsetOf(domGlsl_param_type,elemSamplerDEPTH),"samplerDEPTH"); 
+    _Meta->appendElement(domGlsl_param_type::domEnum::registerElement(),daeOffsetOf(domGlsl_param_type,elemEnum));
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domGlsl_param_type,_contents));
+
+	
+	
+	_Meta->setElementSize(sizeof(domGlsl_param_type));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domGlsl_param_type::domBool::create(daeInt bytes)
+{
+	domGlsl_param_type::domBoolRef ref = new(bytes) domGlsl_param_type::domBool;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domBool::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "bool" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domBool::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domBool::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_param_type::domBool2Ref ref = new(bytes) domGlsl_param_type::domBool2;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domBool2::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "bool2" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domBool2::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domBool2::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_param_type::domBool3Ref ref = new(bytes) domGlsl_param_type::domBool3;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domBool3::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "bool3" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domBool3::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domBool3::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_param_type::domBool4Ref ref = new(bytes) domGlsl_param_type::domBool4;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domBool4::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "bool4" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domBool4::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domBool4::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_param_type::domFloatRef ref = new(bytes) domGlsl_param_type::domFloat;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domFloat::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domFloat::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domFloat::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_param_type::domFloat2Ref ref = new(bytes) domGlsl_param_type::domFloat2;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domFloat2::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float2" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domFloat2::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domFloat2::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_param_type::domFloat3Ref ref = new(bytes) domGlsl_param_type::domFloat3;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domFloat3::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float3" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domFloat3::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domFloat3::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_param_type::domFloat4Ref ref = new(bytes) domGlsl_param_type::domFloat4;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domFloat4::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float4" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domFloat4::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domFloat4::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_param_type::domFloat2x2Ref ref = new(bytes) domGlsl_param_type::domFloat2x2;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domFloat2x2::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float2x2" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domFloat2x2::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domFloat2x2::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_param_type::domFloat3x3Ref ref = new(bytes) domGlsl_param_type::domFloat3x3;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domFloat3x3::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float3x3" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domFloat3x3::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domFloat3x3::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_param_type::domFloat4x4Ref ref = new(bytes) domGlsl_param_type::domFloat4x4;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domFloat4x4::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "float4x4" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domFloat4x4::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domFloat4x4::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_param_type::domIntRef ref = new(bytes) domGlsl_param_type::domInt;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domInt::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "int" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domInt::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domInt::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_param_type::domInt2Ref ref = new(bytes) domGlsl_param_type::domInt2;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domInt2::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "int2" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domInt2::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domInt2::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_param_type::domInt3Ref ref = new(bytes) domGlsl_param_type::domInt3;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domInt3::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "int3" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domInt3::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domInt3::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_param_type::domInt4Ref ref = new(bytes) domGlsl_param_type::domInt4;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domInt4::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "int4" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domInt4::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domInt4::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_param_type::domEnumRef ref = new(bytes) domGlsl_param_type::domEnum;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_param_type::domEnum::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "enum" );
+	_Meta->setStaticPointerAddress(&domGlsl_param_type::domEnum::_Meta);
+	_Meta->registerConstructor(domGlsl_param_type::domEnum::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGlsl_param_type::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domBool::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domBool2::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domBool3::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domBool4::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domFloat::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domFloat2::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domFloat3::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domFloat4::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domFloat2x2::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domFloat3x3::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domFloat4x4::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domInt::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domInt2::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domInt3::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domInt4::_Meta = NULL;
+daeMetaElement * domGlsl_param_type::domEnum::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGlsl_setarray_type.cpp

@@ -0,0 +1,87 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGlsl_setarray_type.h>
+
+daeElementRef
+domGlsl_setarray_type::create(daeInt bytes)
+{
+	domGlsl_setarray_typeRef ref = new(bytes) domGlsl_setarray_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_setarray_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "glsl_setarray_type" );
+	_Meta->setStaticPointerAddress(&domGlsl_setarray_type::_Meta);
+	_Meta->registerConstructor(domGlsl_setarray_type::create);
+
+	// Add elements: glsl_param_type, array
+    _Meta->appendArrayElement(domGlsl_param_type::registerElement(),daeOffsetOf(domGlsl_setarray_type,elemGlsl_param_type_array));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "surface", _Meta->getMetaElements()[0], "fx_surface_common");
+	_Meta->appendPossibleChild( "sampler1D", _Meta->getMetaElements()[0], "gl_sampler1D");
+	_Meta->appendPossibleChild( "sampler2D", _Meta->getMetaElements()[0], "gl_sampler2D");
+	_Meta->appendPossibleChild( "sampler3D", _Meta->getMetaElements()[0], "gl_sampler3D");
+	_Meta->appendPossibleChild( "samplerCUBE", _Meta->getMetaElements()[0], "gl_samplerCUBE");
+	_Meta->appendPossibleChild( "samplerRECT", _Meta->getMetaElements()[0], "gl_samplerRECT");
+	_Meta->appendPossibleChild( "samplerDEPTH", _Meta->getMetaElements()[0], "gl_samplerDEPTH");
+	_Meta->appendPossibleChild( "enum", _Meta->getMetaElements()[0]);
+    _Meta->appendArrayElement(domGlsl_setarray_type::registerElement(),daeOffsetOf(domGlsl_setarray_type,elemArray_array),"array"); 
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domGlsl_setarray_type,_contents));
+
+
+	//	Add attribute: length
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "length" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGlsl_setarray_type::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGlsl_setparam.cpp

@@ -0,0 +1,99 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domGlsl_setparam.h>
+
+daeElementRef
+domGlsl_setparam::create(daeInt bytes)
+{
+	domGlsl_setparamRef ref = new(bytes) domGlsl_setparam;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_setparam::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "glsl_setparam" );
+	_Meta->setStaticPointerAddress(&domGlsl_setparam::_Meta);
+	_Meta->registerConstructor(domGlsl_setparam::create);
+
+	// Add elements: annotate, glsl_param_type, array
+    _Meta->appendArrayElement(domFx_annotate_common::registerElement(),daeOffsetOf(domGlsl_setparam,elemAnnotate_array),"annotate"); 
+    _Meta->appendElement(domGlsl_param_type::registerElement(),daeOffsetOf(domGlsl_setparam,elemGlsl_param_type));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "surface", _Meta->getMetaElements()[1], "fx_surface_common");
+	_Meta->appendPossibleChild( "sampler1D", _Meta->getMetaElements()[1], "gl_sampler1D");
+	_Meta->appendPossibleChild( "sampler2D", _Meta->getMetaElements()[1], "gl_sampler2D");
+	_Meta->appendPossibleChild( "sampler3D", _Meta->getMetaElements()[1], "gl_sampler3D");
+	_Meta->appendPossibleChild( "samplerCUBE", _Meta->getMetaElements()[1], "gl_samplerCUBE");
+	_Meta->appendPossibleChild( "samplerRECT", _Meta->getMetaElements()[1], "gl_samplerRECT");
+	_Meta->appendPossibleChild( "samplerDEPTH", _Meta->getMetaElements()[1], "gl_samplerDEPTH");
+	_Meta->appendPossibleChild( "enum", _Meta->getMetaElements()[1]);
+    _Meta->appendElement(domGlsl_setarray_type::registerElement(),daeOffsetOf(domGlsl_setparam,elemArray),"array"); 
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domGlsl_setparam,_contents));
+
+
+	//	Add attribute: ref
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "ref" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("xsNCName"));
+		ma->setOffset( daeOffsetOf( domGlsl_setparam , attrProgram ));
+		ma->setContainer( _Meta );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domGlsl_setparam));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domGlsl_setparam::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGlsl_setparam_simple.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/daeDom.h>
+#include <dom/domGlsl_setparam_simple.h>
+
+daeElementRef
+domGlsl_setparam_simple::create(daeInt bytes)
+{
+	domGlsl_setparam_simpleRef ref = new(bytes) domGlsl_setparam_simple;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_setparam_simple::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "glsl_setparam_simple" );
+	_Meta->setStaticPointerAddress(&domGlsl_setparam_simple::_Meta);
+	_Meta->registerConstructor(domGlsl_setparam_simple::create);
+
+	// Add elements: annotate, glsl_param_type
+    _Meta->appendArrayElement(domFx_annotate_common::registerElement(),daeOffsetOf(domGlsl_setparam_simple,elemAnnotate_array),"annotate"); 
+    _Meta->appendElement(domGlsl_param_type::registerElement(),daeOffsetOf(domGlsl_setparam_simple,elemGlsl_param_type));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[1]);
+	_Meta->appendPossibleChild( "surface", _Meta->getMetaElements()[1], "fx_surface_common");
+	_Meta->appendPossibleChild( "sampler1D", _Meta->getMetaElements()[1], "gl_sampler1D");
+	_Meta->appendPossibleChild( "sampler2D", _Meta->getMetaElements()[1], "gl_sampler2D");
+	_Meta->appendPossibleChild( "sampler3D", _Meta->getMetaElements()[1], "gl_sampler3D");
+	_Meta->appendPossibleChild( "samplerCUBE", _Meta->getMetaElements()[1], "gl_samplerCUBE");
+	_Meta->appendPossibleChild( "samplerRECT", _Meta->getMetaElements()[1], "gl_samplerRECT");
+	_Meta->appendPossibleChild( "samplerDEPTH", _Meta->getMetaElements()[1], "gl_samplerDEPTH");
+	_Meta->appendPossibleChild( "enum", _Meta->getMetaElements()[1]);
+
+	//	Add attribute: ref
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "ref" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGlsl_setparam_simple::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domGlsl_surface_type.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/daeDom.h>
+#include <dom/domGlsl_surface_type.h>
+
+daeElementRef
+domGlsl_surface_type::create(daeInt bytes)
+{
+	domGlsl_surface_typeRef ref = new(bytes) domGlsl_surface_type;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_surface_type::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "glsl_surface_type" );
+	_Meta->setStaticPointerAddress(&domGlsl_surface_type::_Meta);
+	_Meta->registerConstructor(domGlsl_surface_type::create);
+
+	// Add elements: init_from, format, size, viewport_ratio, mip_levels, mipmap_generate, generator
+    _Meta->appendArrayElement(domInit_from::registerElement(),daeOffsetOf(domGlsl_surface_type,elemInit_from_array));
+    _Meta->appendElement(domFormat::registerElement(),daeOffsetOf(domGlsl_surface_type,elemFormat));
+    _Meta->appendElement(domSize::registerElement(),daeOffsetOf(domGlsl_surface_type,elemSize));
+    _Meta->appendElement(domViewport_ratio::registerElement(),daeOffsetOf(domGlsl_surface_type,elemViewport_ratio));
+    _Meta->appendElement(domMip_levels::registerElement(),daeOffsetOf(domGlsl_surface_type,elemMip_levels));
+    _Meta->appendElement(domMipmap_generate::registerElement(),daeOffsetOf(domGlsl_surface_type,elemMipmap_generate));
+    _Meta->appendElement(domGenerator::registerElement(),daeOffsetOf(domGlsl_surface_type,elemGenerator));
+
+	//	Add attribute: type
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "type" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domGlsl_surface_type::domGeneratorRef ref = new(bytes) domGlsl_surface_type::domGenerator;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_surface_type::domGenerator::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "generator" );
+	_Meta->setStaticPointerAddress(&domGlsl_surface_type::domGenerator::_Meta);
+	_Meta->registerConstructor(domGlsl_surface_type::domGenerator::create);
+
+	// Add elements: annotate, code, include, name, setparam
+    _Meta->appendArrayElement(domFx_annotate_common::registerElement(),daeOffsetOf(domGlsl_surface_type::domGenerator,elemAnnotate_array),"annotate"); 
+    _Meta->appendArrayElement(domFx_code_profile::registerElement(),daeOffsetOf(domGlsl_surface_type::domGenerator,elemCode_array),"code"); 
+    _Meta->appendArrayElement(domFx_include_common::registerElement(),daeOffsetOf(domGlsl_surface_type::domGenerator,elemInclude_array),"include"); 
+    _Meta->appendElement(domGlsl_surface_type::domGenerator::domName::registerElement(),daeOffsetOf(domGlsl_surface_type::domGenerator,elemName));
+    _Meta->appendArrayElement(domGlsl_setparam_simple::registerElement(),daeOffsetOf(domGlsl_surface_type::domGenerator,elemSetparam_array),"setparam"); 
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domGlsl_surface_type::domGenerator,_contents));
+
+	
+	
+	_Meta->setElementSize(sizeof(domGlsl_surface_type::domGenerator));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domGlsl_surface_type::domGenerator::domName::create(daeInt bytes)
+{
+	domGlsl_surface_type::domGenerator::domNameRef ref = new(bytes) domGlsl_surface_type::domGenerator::domName;
+	return ref;
+}
+
+
+daeMetaElement *
+domGlsl_surface_type::domGenerator::domName::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "name" );
+	_Meta->setStaticPointerAddress(&domGlsl_surface_type::domGenerator::domName::_Meta);
+	_Meta->registerConstructor(domGlsl_surface_type::domGenerator::domName::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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;
+}
+
+
+daeMetaElement * domGlsl_surface_type::_Meta = NULL;
+daeMetaElement * domGlsl_surface_type::domGenerator::_Meta = NULL;
+daeMetaElement * domGlsl_surface_type::domGenerator::domName::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domIDREF_array.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/daeDom.h>
+#include <dom/domIDREF_array.h>
+
+daeElementRef
+domIDREF_array::create(daeInt bytes)
+{
+	domIDREF_arrayRef ref = new(bytes) domIDREF_array;
+	return ref;
+}
+
+
+daeMetaElement *
+domIDREF_array::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "IDREF_array" );
+	_Meta->setStaticPointerAddress(&domIDREF_array::_Meta);
+	_Meta->registerConstructor(domIDREF_array::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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( daeAtomicType::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( daeAtomicType::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;
+}
+
+
+daeMetaElement * domIDREF_array::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domImage.cpp

@@ -0,0 +1,194 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domImage.h>
+
+daeElementRef
+domImage::create(daeInt bytes)
+{
+	domImageRef ref = new(bytes) domImage;
+	return ref;
+}
+
+
+daeMetaElement *
+domImage::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "image" );
+	_Meta->setStaticPointerAddress(&domImage::_Meta);
+	_Meta->registerConstructor(domImage::create);
+
+	// Add elements: asset, data, init_from, extra
+    _Meta->appendElement(domAsset::registerElement(),daeOffsetOf(domImage,elemAsset));
+    _Meta->appendElement(domImage::domData::registerElement(),daeOffsetOf(domImage,elemData));
+    _Meta->appendElement(domImage::domInit_from::registerElement(),daeOffsetOf(domImage,elemInit_from));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domImage,elemExtra_array));
+	// Ordered list of sub-elements
+    _Meta->addContents(daeOffsetOf(domImage,_contents));
+
+
+	//	Add attribute: id
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "id" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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( daeAtomicType::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( daeAtomicType::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( daeAtomicType::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( daeAtomicType::get("Uint"));
+		ma->setOffset( daeOffsetOf( domImage , attrDepth ));
+		ma->setContainer( _Meta );
+		ma->setDefault( "1");
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domImage));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domImage::domData::create(daeInt bytes)
+{
+	domImage::domDataRef ref = new(bytes) domImage::domData;
+	return ref;
+}
+
+
+daeMetaElement *
+domImage::domData::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "data" );
+	_Meta->setStaticPointerAddress(&domImage::domData::_Meta);
+	_Meta->registerConstructor(domImage::domData::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaArrayAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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(daeInt bytes)
+{
+	domImage::domInit_fromRef ref = new(bytes) domImage::domInit_from;
+	ref->_value.setContainer( (domImage::domInit_from*)ref );
+	return ref;
+}
+
+
+daeMetaElement *
+domImage::domInit_from::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "init_from" );
+	_Meta->setStaticPointerAddress(&domImage::domInit_from::_Meta);
+	_Meta->registerConstructor(domImage::domInit_from::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::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;
+}
+
+
+daeMetaElement * domImage::_Meta = NULL;
+daeMetaElement * domImage::domData::_Meta = NULL;
+daeMetaElement * domImage::domInit_from::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domInputGlobal.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/daeDom.h>
+#include <dom/domInputGlobal.h>
+
+daeElementRef
+domInputGlobal::create(daeInt bytes)
+{
+	domInputGlobalRef ref = new(bytes) domInputGlobal;
+	ref->attrSource.setContainer( (domInputGlobal*)ref );
+	return ref;
+}
+
+
+daeMetaElement *
+domInputGlobal::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "InputGlobal" );
+	_Meta->setStaticPointerAddress(&domInputGlobal::_Meta);
+	_Meta->registerConstructor(domInputGlobal::create);
+
+
+	//	Add attribute: semantic
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "semantic" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("xsAnyURI"));
+		ma->setOffset( daeOffsetOf( domInputGlobal , attrSource ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domInputGlobal));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domInputGlobal::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domInputLocal.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/daeDom.h>
+#include <dom/domInputLocal.h>
+
+daeElementRef
+domInputLocal::create(daeInt bytes)
+{
+	domInputLocalRef ref = new(bytes) domInputLocal;
+	ref->attrSource.setContainer( (domInputLocal*)ref );
+	return ref;
+}
+
+
+daeMetaElement *
+domInputLocal::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "InputLocal" );
+	_Meta->setStaticPointerAddress(&domInputLocal::_Meta);
+	_Meta->registerConstructor(domInputLocal::create);
+
+
+	//	Add attribute: semantic
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "semantic" );
+		ma->setType( daeAtomicType::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( daeAtomicType::get("URIFragmentType"));
+		ma->setOffset( daeOffsetOf( domInputLocal , attrSource ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domInputLocal));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domInputLocal::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domInputLocalOffset.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/daeDom.h>
+#include <dom/domInputLocalOffset.h>
+
+daeElementRef
+domInputLocalOffset::create(daeInt bytes)
+{
+	domInputLocalOffsetRef ref = new(bytes) domInputLocalOffset;
+	ref->attrSource.setContainer( (domInputLocalOffset*)ref );
+	return ref;
+}
+
+
+daeMetaElement *
+domInputLocalOffset::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "InputLocalOffset" );
+	_Meta->setStaticPointerAddress(&domInputLocalOffset::_Meta);
+	_Meta->registerConstructor(domInputLocalOffset::create);
+
+
+	//	Add attribute: offset
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "offset" );
+		ma->setType( daeAtomicType::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( daeAtomicType::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( daeAtomicType::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( daeAtomicType::get("Uint"));
+		ma->setOffset( daeOffsetOf( domInputLocalOffset , attrSet ));
+		ma->setContainer( _Meta );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domInputLocalOffset));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domInputLocalOffset::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domInstanceWithExtra.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/daeDom.h>
+#include <dom/domInstanceWithExtra.h>
+
+daeElementRef
+domInstanceWithExtra::create(daeInt bytes)
+{
+	domInstanceWithExtraRef ref = new(bytes) domInstanceWithExtra;
+	ref->attrUrl.setContainer( (domInstanceWithExtra*)ref );
+	return ref;
+}
+
+
+daeMetaElement *
+domInstanceWithExtra::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "InstanceWithExtra" );
+	_Meta->setStaticPointerAddress(&domInstanceWithExtra::_Meta);
+	_Meta->registerConstructor(domInstanceWithExtra::create);
+
+	// Add elements: extra
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domInstanceWithExtra,elemExtra_array));
+
+	//	Add attribute: url
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "url" );
+		ma->setType( daeAtomicType::get("xsAnyURI"));
+		ma->setOffset( daeOffsetOf( domInstanceWithExtra , attrUrl ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domInstanceWithExtra));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domInstanceWithExtra::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domInstance_camera.cpp

@@ -0,0 +1,60 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domInstance_camera.h>
+
+daeElementRef
+domInstance_camera::create(daeInt bytes)
+{
+	domInstance_cameraRef ref = new(bytes) domInstance_camera;
+	return ref;
+}
+
+
+daeMetaElement *
+domInstance_camera::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "instance_camera" );
+	_Meta->setStaticPointerAddress(&domInstance_camera::_Meta);
+	_Meta->registerConstructor(domInstance_camera::create);
+
+	// Add elements: extra
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domInstance_camera,elemExtra_array));
+
+	//	Add attribute: url
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "url" );
+		ma->setType( daeAtomicType::get("xsAnyURI"));
+		ma->setOffset( daeOffsetOf( domInstance_camera , attrUrl ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domInstance_camera));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domInstance_camera::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domInstance_controller.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/daeDom.h>
+#include <dom/domInstance_controller.h>
+
+daeElementRef
+domInstance_controller::create(daeInt bytes)
+{
+	domInstance_controllerRef ref = new(bytes) domInstance_controller;
+	ref->attrUrl.setContainer( (domInstance_controller*)ref );
+	return ref;
+}
+
+
+daeMetaElement *
+domInstance_controller::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "instance_controller" );
+	_Meta->setStaticPointerAddress(&domInstance_controller::_Meta);
+	_Meta->registerConstructor(domInstance_controller::create);
+
+	// Add elements: skeleton, bind_material, extra
+    _Meta->appendArrayElement(domInstance_controller::domSkeleton::registerElement(),daeOffsetOf(domInstance_controller,elemSkeleton_array));
+    _Meta->appendElement(domBind_material::registerElement(),daeOffsetOf(domInstance_controller,elemBind_material));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domInstance_controller,elemExtra_array));
+
+	//	Add attribute: url
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "url" );
+		ma->setType( daeAtomicType::get("xsAnyURI"));
+		ma->setOffset( daeOffsetOf( domInstance_controller , attrUrl ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domInstance_controller));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domInstance_controller::domSkeleton::create(daeInt bytes)
+{
+	domInstance_controller::domSkeletonRef ref = new(bytes) domInstance_controller::domSkeleton;
+	ref->_value.setContainer( (domInstance_controller::domSkeleton*)ref );
+	return ref;
+}
+
+
+daeMetaElement *
+domInstance_controller::domSkeleton::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "skeleton" );
+	_Meta->setStaticPointerAddress(&domInstance_controller::domSkeleton::_Meta);
+	_Meta->registerConstructor(domInstance_controller::domSkeleton::create);
+
+	//	Add attribute: _value
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "_value" );
+		ma->setType( daeAtomicType::get("xsAnyURI"));
+		ma->setOffset( daeOffsetOf( domInstance_controller::domSkeleton , _value ));
+		ma->setContainer( _Meta );
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domInstance_controller::domSkeleton));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domInstance_controller::_Meta = NULL;
+daeMetaElement * domInstance_controller::domSkeleton::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domInstance_effect.cpp

@@ -0,0 +1,191 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domInstance_effect.h>
+
+daeElementRef
+domInstance_effect::create(daeInt bytes)
+{
+	domInstance_effectRef ref = new(bytes) domInstance_effect;
+	ref->attrUrl.setContainer( (domInstance_effect*)ref );
+	return ref;
+}
+
+
+daeMetaElement *
+domInstance_effect::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "instance_effect" );
+	_Meta->setStaticPointerAddress(&domInstance_effect::_Meta);
+	_Meta->registerConstructor(domInstance_effect::create);
+
+	// Add elements: technique_hint, setparam, extra
+    _Meta->appendArrayElement(domInstance_effect::domTechnique_hint::registerElement(),daeOffsetOf(domInstance_effect,elemTechnique_hint_array));
+    _Meta->appendArrayElement(domInstance_effect::domSetparam::registerElement(),daeOffsetOf(domInstance_effect,elemSetparam_array));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domInstance_effect,elemExtra_array));
+
+	//	Add attribute: url
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "url" );
+		ma->setType( daeAtomicType::get("xsAnyURI"));
+		ma->setOffset( daeOffsetOf( domInstance_effect , attrUrl ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domInstance_effect));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domInstance_effect::domTechnique_hint::create(daeInt bytes)
+{
+	domInstance_effect::domTechnique_hintRef ref = new(bytes) domInstance_effect::domTechnique_hint;
+	return ref;
+}
+
+
+daeMetaElement *
+domInstance_effect::domTechnique_hint::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "technique_hint" );
+	_Meta->setStaticPointerAddress(&domInstance_effect::domTechnique_hint::_Meta);
+	_Meta->registerConstructor(domInstance_effect::domTechnique_hint::create);
+
+
+	//	Add attribute: platform
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "platform" );
+		ma->setType( daeAtomicType::get("xsNCName"));
+		ma->setOffset( daeOffsetOf( domInstance_effect::domTechnique_hint , attrPlatform ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+
+	//	Add attribute: ref
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "ref" );
+		ma->setType( daeAtomicType::get("xsNCName"));
+		ma->setOffset( daeOffsetOf( domInstance_effect::domTechnique_hint , attrRef ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domInstance_effect::domTechnique_hint));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+daeElementRef
+domInstance_effect::domSetparam::create(daeInt bytes)
+{
+	domInstance_effect::domSetparamRef ref = new(bytes) domInstance_effect::domSetparam;
+	return ref;
+}
+
+
+daeMetaElement *
+domInstance_effect::domSetparam::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "setparam" );
+	_Meta->setStaticPointerAddress(&domInstance_effect::domSetparam::_Meta);
+	_Meta->registerConstructor(domInstance_effect::domSetparam::create);
+
+	// Add elements: fx_basic_type_common
+    _Meta->appendElement(domFx_basic_type_common::registerElement(),daeOffsetOf(domInstance_effect::domSetparam,elemFx_basic_type_common));
+	_Meta->appendPossibleChild( "bool", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "bool4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "int4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float1x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float2x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float3x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x1", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x2", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x3", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "float4x4", _Meta->getMetaElements()[0]);
+	_Meta->appendPossibleChild( "surface", _Meta->getMetaElements()[0], "fx_surface_common");
+	_Meta->appendPossibleChild( "sampler1D", _Meta->getMetaElements()[0], "fx_sampler1D_common");
+	_Meta->appendPossibleChild( "sampler2D", _Meta->getMetaElements()[0], "fx_sampler2D_common");
+	_Meta->appendPossibleChild( "sampler3D", _Meta->getMetaElements()[0], "fx_sampler3D_common");
+	_Meta->appendPossibleChild( "samplerCUBE", _Meta->getMetaElements()[0], "fx_samplerCUBE_common");
+	_Meta->appendPossibleChild( "samplerRECT", _Meta->getMetaElements()[0], "fx_samplerRECT_common");
+	_Meta->appendPossibleChild( "samplerDEPTH", _Meta->getMetaElements()[0], "fx_samplerDEPTH_common");
+	_Meta->appendPossibleChild( "enum", _Meta->getMetaElements()[0]);
+
+	//	Add attribute: ref
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "ref" );
+		ma->setType( daeAtomicType::get("xsNCName"));
+		ma->setOffset( daeOffsetOf( domInstance_effect::domSetparam , attrRef ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domInstance_effect::domSetparam));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domInstance_effect::_Meta = NULL;
+daeMetaElement * domInstance_effect::domTechnique_hint::_Meta = NULL;
+daeMetaElement * domInstance_effect::domSetparam::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domInstance_force_field.cpp

@@ -0,0 +1,60 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domInstance_force_field.h>
+
+daeElementRef
+domInstance_force_field::create(daeInt bytes)
+{
+	domInstance_force_fieldRef ref = new(bytes) domInstance_force_field;
+	return ref;
+}
+
+
+daeMetaElement *
+domInstance_force_field::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "instance_force_field" );
+	_Meta->setStaticPointerAddress(&domInstance_force_field::_Meta);
+	_Meta->registerConstructor(domInstance_force_field::create);
+
+	// Add elements: extra
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domInstance_force_field,elemExtra_array));
+
+	//	Add attribute: url
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "url" );
+		ma->setType( daeAtomicType::get("xsAnyURI"));
+		ma->setOffset( daeOffsetOf( domInstance_force_field , attrUrl ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domInstance_force_field));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domInstance_force_field::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domInstance_geometry.cpp

@@ -0,0 +1,62 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domInstance_geometry.h>
+
+daeElementRef
+domInstance_geometry::create(daeInt bytes)
+{
+	domInstance_geometryRef ref = new(bytes) domInstance_geometry;
+	ref->attrUrl.setContainer( (domInstance_geometry*)ref );
+	return ref;
+}
+
+
+daeMetaElement *
+domInstance_geometry::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "instance_geometry" );
+	_Meta->setStaticPointerAddress(&domInstance_geometry::_Meta);
+	_Meta->registerConstructor(domInstance_geometry::create);
+
+	// Add elements: bind_material, extra
+    _Meta->appendElement(domBind_material::registerElement(),daeOffsetOf(domInstance_geometry,elemBind_material));
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domInstance_geometry,elemExtra_array));
+
+	//	Add attribute: url
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "url" );
+		ma->setType( daeAtomicType::get("xsAnyURI"));
+		ma->setOffset( daeOffsetOf( domInstance_geometry , attrUrl ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domInstance_geometry));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domInstance_geometry::_Meta = NULL;
+
+

Extras/COLLADA_DOM/src/1.4/dom/domInstance_light.cpp

@@ -0,0 +1,60 @@
+/*
+ * 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/daeDom.h>
+#include <dom/domInstance_light.h>
+
+daeElementRef
+domInstance_light::create(daeInt bytes)
+{
+	domInstance_lightRef ref = new(bytes) domInstance_light;
+	return ref;
+}
+
+
+daeMetaElement *
+domInstance_light::registerElement()
+{
+    if ( _Meta != NULL ) return _Meta;
+    
+    _Meta = new daeMetaElement;
+    _Meta->setName( "instance_light" );
+	_Meta->setStaticPointerAddress(&domInstance_light::_Meta);
+	_Meta->registerConstructor(domInstance_light::create);
+
+	// Add elements: extra
+    _Meta->appendArrayElement(domExtra::registerElement(),daeOffsetOf(domInstance_light,elemExtra_array));
+
+	//	Add attribute: url
+ 	{
+		daeMetaAttribute *ma = new daeMetaAttribute;
+		ma->setName( "url" );
+		ma->setType( daeAtomicType::get("xsAnyURI"));
+		ma->setOffset( daeOffsetOf( domInstance_light , attrUrl ));
+		ma->setContainer( _Meta );
+		ma->setIsRequired( true );
+	
+		_Meta->appendAttribute(ma);
+	}
+	
+	
+	_Meta->setElementSize(sizeof(domInstance_light));
+	_Meta->validate();
+
+	return _Meta;
+}
+
+
+daeMetaElement * domInstance_light::_Meta = NULL;
+
+