Merge pull request #615 from delicious-monster/master

I made changes to the Collada importer so it will import SketchUp DAEs.

code/BoostWorkaround/boost/format.hpp

@@ -1,82 +1,82 @@
-
-
-
-/* DEPRECATED! - use code/TinyFormatter.h instead.
- *
- *
- * */
-
-#ifndef AI_BOOST_FORMAT_DUMMY_INCLUDED
-#define AI_BOOST_FORMAT_DUMMY_INCLUDED
-
-#if (!defined BOOST_FORMAT_HPP) || (defined ASSIMP_FORCE_NOBOOST)
-
-#include <string>
-#include <vector>
-#include <sstream> 
-
-namespace boost
-{
-
-
-	class format
-	{
-	public:
-		format (const std::string& _d)
-			: d(_d)
-		{
-		}
-
-		template <typename T>
-		format& operator % (T in) 
-		{
-			// XXX add replacement for boost::lexical_cast?
-			
-			std::ostringstream ss;
-			ss << in; // note: ss cannot be an rvalue, or  the global operator << (const char*) is not called for T == const char*.
-			chunks.push_back( ss.str());
-			return *this;
-		}
-
-
-		operator std::string () const {
-			std::string res; // pray for NRVO to kick in
-
-			size_t start = 0, last = 0;
-
-			std::vector<std::string>::const_iterator chunkin = chunks.begin();
-
-			for ( start = d.find('%');start != std::string::npos;  start = d.find('%',last)) {
-				res += d.substr(last,start-last);
-				last = start+2;
-				if (d[start+1] == '%') {
-					res += "%";
-					continue;
-				}
-
-				if (chunkin == chunks.end()) {
-					break;
-				}
-
-				res += *chunkin++;
-			}
-			res += d.substr(last);
-			return res;
-		}
-
-	private:
-		std::string d;
-		std::vector<std::string> chunks;
-	};
-
-	inline std::string str(const std::string& s) {
-		return s;
-	} 
-}
-
-
-#else
-#	error "format.h was already included"
-#endif //
-#endif // !! AI_BOOST_FORMAT_DUMMY_INCLUDED
-
+
+
+
+/* DEPRECATED! - use code/TinyFormatter.h instead.
+ *
+ *
+ * */
+
+#ifndef AI_BOOST_FORMAT_DUMMY_INCLUDED
+#define AI_BOOST_FORMAT_DUMMY_INCLUDED
+
+#if (!defined BOOST_FORMAT_HPP) || (defined ASSIMP_FORCE_NOBOOST)
+
+#include <string>
+#include <vector>
+#include <sstream> 
+
+namespace boost
+{
+
+
+	class format
+	{
+	public:
+		format (const std::string& _d)
+			: d(_d)
+		{
+		}
+
+		template <typename T>
+		format& operator % (T in) 
+		{
+			// XXX add replacement for boost::lexical_cast?
+			
+			std::ostringstream ss;
+			ss << in; // note: ss cannot be an rvalue, or  the global operator << (const char*) is not called for T == const char*.
+			chunks.push_back( ss.str());
+			return *this;
+		}
+
+
+		operator std::string () const {
+			std::string res; // pray for NRVO to kick in
+
+			size_t start = 0, last = 0;
+
+			std::vector<std::string>::const_iterator chunkin = chunks.begin();
+
+			for ( start = d.find('%');start != std::string::npos;  start = d.find('%',last)) {
+				res += d.substr(last,start-last);
+				last = start+2;
+				if (d[start+1] == '%') {
+					res += "%";
+					continue;
+				}
+
+				if (chunkin == chunks.end()) {
+					break;
+				}
+
+				res += *chunkin++;
+			}
+			res += d.substr(last);
+			return res;
+		}
+
+	private:
+		std::string d;
+		std::vector<std::string> chunks;
+	};
+
+	inline std::string str(const std::string& s) {
+		return s;
+	} 
+}
+
+
+#else
+#	error "format.h was already included"
+#endif //
+#endif // !! AI_BOOST_FORMAT_DUMMY_INCLUDED
+

code/BoostWorkaround/boost/shared_ptr.hpp

@@ -1,260 +1,260 @@
-
-#ifndef INCLUDED_AI_BOOST_SHARED_PTR
-#define INCLUDED_AI_BOOST_SHARED_PTR
-
-#ifndef BOOST_SHARED_PTR_HPP_INCLUDED
-
-// ------------------------------
-// Internal stub
-
-#include <stddef.h> //NULL
-#include <algorithm> //std::swap
-namespace boost {
-	namespace detail {
-		class controller {
-		public:
-
-			controller()
-				: cnt(1)
-			{}
-		
-		public:
-
-			template <typename T>
-			controller* decref(T* pt) {
-				if (--cnt <= 0) {
-					delete this;
-					delete pt;
-				}
-				return NULL;
-			}
-		
-			controller* incref() {
-				++cnt;
-				return this;
-			}
-
-			long get() const {
-				return cnt;
-			}
-
-		private:
-			long cnt;
-		};
-
-		struct empty {};
-		
-		template <typename DEST, typename SRC>
-		struct is_convertible_stub {
-			
-			struct yes {char s[1];};
-			struct no  {char s[2];};
-
-			static yes foo(DEST*);
-			static no  foo(...);
-
-			enum {result = (sizeof(foo((SRC*)0)) == sizeof(yes) ? 1 : 0)};	
-		};
-
-		template <bool> struct enable_if {};
-		template <> struct enable_if<true> {
-			typedef empty result;
-		};
-
-		template <typename DEST, typename SRC>
-		struct is_convertible : public enable_if<is_convertible_stub<DEST,SRC>::result > {
-		};
-	}
-
-// ------------------------------
-// Small replacement for boost::shared_ptr, not threadsafe because no
-// atomic reference counter is in use.
-// ------------------------------
-template <class T>
-class shared_ptr
-{
-	template <typename TT> friend class shared_ptr;
-
-	template<class TT, class U> friend shared_ptr<TT> static_pointer_cast   (shared_ptr<U> ptr);
-	template<class TT, class U> friend shared_ptr<TT> dynamic_pointer_cast  (shared_ptr<U> ptr);
-	template<class TT, class U> friend shared_ptr<TT> const_pointer_cast    (shared_ptr<U> ptr);
-
-	template<class TT> friend bool operator== (const shared_ptr<TT>& a, const shared_ptr<TT>& b);
-	template<class TT> friend bool operator!= (const shared_ptr<TT>& a, const shared_ptr<TT>& b);
-	template<class TT> friend bool operator<  (const shared_ptr<TT>& a, const shared_ptr<TT>& b);
-
-public:
-
-	typedef T element_type;
-
-public:
-
-	// provide a default constructor
-	shared_ptr()
-		: ptr()
-		, ctr(NULL)
-	{
-	}
-
-	// construction from an existing object of type T
-	explicit shared_ptr(T* ptr)
-		: ptr(ptr)
-		, ctr(ptr ? new detail::controller() : NULL)
-	{
-	}
-
-	shared_ptr(const shared_ptr& r)
-		: ptr(r.ptr)
-		, ctr(r.ctr ? r.ctr->incref() : NULL)
-	{
-	}
-
-	template <typename Y>
-	shared_ptr(const shared_ptr<Y>& r,typename detail::is_convertible<T,Y>::result = detail::empty())
-		: ptr(r.ptr)
-		, ctr(r.ctr ? r.ctr->incref() : NULL)
-	{
-	}
-
-	// automatic destruction of the wrapped object when all
-	// references are freed.
-	~shared_ptr()	{
-		if (ctr) {
-			ctr = ctr->decref(ptr);
-		}
-	}
-
-	shared_ptr& operator=(const shared_ptr& r) {
-		if (this == &r) {
-			return *this;
-		}
-		if (ctr) {
-			ctr->decref(ptr);
-		}
-		ptr = r.ptr;
-		ctr = ptr?r.ctr->incref():NULL;
-		return *this;
-	}
-
-	template <typename Y>
-	shared_ptr& operator=(const shared_ptr<Y>& r) {
-		if (this == &r) {
-			return *this;
-		}
-		if (ctr) {
-			ctr->decref(ptr);
-		}
-		ptr = r.ptr;
-		ctr = ptr?r.ctr->incref():NULL;
-		return *this;
-	}
-
-	// pointer access
-	inline operator T*() const {
-		return ptr;
-	}
-
-	inline T* operator-> () const	{
-		return ptr;
-	}
-
-	// standard semantics
-	inline T* get() {
-		return ptr;
-	}
-
-	inline const T* get() const	{
-		return ptr;
-	}
-
-	inline operator bool () const {
-		return ptr != NULL;
-	}
-
-	inline bool unique() const {
-		return use_count() == 1;
-	}
-
-	inline long use_count() const {
-		return ctr->get();
-	}
-
-	inline void reset (T* t = 0)	{
-		if (ctr) {
-			ctr->decref(ptr);
-		}
-		ptr = t;
-		ctr = ptr?new detail::controller():NULL;
-	}
-
-	void swap(shared_ptr & b)	{
-		std::swap(ptr, b.ptr);
-		std::swap(ctr, b.ctr);
-	}
-
-private:
-
-
-	// for use by the various xxx_pointer_cast helper templates
-	explicit shared_ptr(T* ptr, detail::controller* ctr)
-		: ptr(ptr)
-		, ctr(ctr->incref())
-	{
-	}
-
-private:
-
-	// encapsulated object pointer
-	T* ptr;
-
-	// control block
-	detail::controller* ctr;
-};
-
-template<class T>
-inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
-{
-	a.swap(b);
-}
-
-template<class T>
-bool operator== (const shared_ptr<T>& a, const shared_ptr<T>& b) {
-	return a.ptr == b.ptr;
-}
-template<class T>
-bool operator!= (const shared_ptr<T>& a, const shared_ptr<T>& b) {
-	return a.ptr != b.ptr;
-}
-	
-template<class T>
-bool operator< (const shared_ptr<T>& a, const shared_ptr<T>& b) {
-	return a.ptr < b.ptr;
-}
-
-
-template<class T, class U>
-inline shared_ptr<T> static_pointer_cast( shared_ptr<U> ptr)
-{  
-   return shared_ptr<T>(static_cast<T*>(ptr.ptr),ptr.ctr);
-}
-
-template<class T, class U>
-inline shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> ptr)
-{  
-   return shared_ptr<T>(dynamic_cast<T*>(ptr.ptr),ptr.ctr);
-}
-
-template<class T, class U>
-inline shared_ptr<T> const_pointer_cast( shared_ptr<U> ptr)
-{  
-   return shared_ptr<T>(const_cast<T*>(ptr.ptr),ptr.ctr);
-}
-
-
-
-} // end of namespace boost
-
-#else
-#	error "shared_ptr.h was already included"
-#endif
-#endif // INCLUDED_AI_BOOST_SHARED_PTR
+
+#ifndef INCLUDED_AI_BOOST_SHARED_PTR
+#define INCLUDED_AI_BOOST_SHARED_PTR
+
+#ifndef BOOST_SHARED_PTR_HPP_INCLUDED
+
+// ------------------------------
+// Internal stub
+
+#include <stddef.h> //NULL
+#include <algorithm> //std::swap
+namespace boost {
+	namespace detail {
+		class controller {
+		public:
+
+			controller()
+				: cnt(1)
+			{}
+		
+		public:
+
+			template <typename T>
+			controller* decref(T* pt) {
+				if (--cnt <= 0) {
+					delete this;
+					delete pt;
+				}
+				return NULL;
+			}
+		
+			controller* incref() {
+				++cnt;
+				return this;
+			}
+
+			long get() const {
+				return cnt;
+			}
+
+		private:
+			long cnt;
+		};
+
+		struct empty {};
+		
+		template <typename DEST, typename SRC>
+		struct is_convertible_stub {
+			
+			struct yes {char s[1];};
+			struct no  {char s[2];};
+
+			static yes foo(DEST*);
+			static no  foo(...);
+
+			enum {result = (sizeof(foo((SRC*)0)) == sizeof(yes) ? 1 : 0)};	
+		};
+
+		template <bool> struct enable_if {};
+		template <> struct enable_if<true> {
+			typedef empty result;
+		};
+
+		template <typename DEST, typename SRC>
+		struct is_convertible : public enable_if<is_convertible_stub<DEST,SRC>::result > {
+		};
+	}
+
+// ------------------------------
+// Small replacement for boost::shared_ptr, not threadsafe because no
+// atomic reference counter is in use.
+// ------------------------------
+template <class T>
+class shared_ptr
+{
+	template <typename TT> friend class shared_ptr;
+
+	template<class TT, class U> friend shared_ptr<TT> static_pointer_cast   (shared_ptr<U> ptr);
+	template<class TT, class U> friend shared_ptr<TT> dynamic_pointer_cast  (shared_ptr<U> ptr);
+	template<class TT, class U> friend shared_ptr<TT> const_pointer_cast    (shared_ptr<U> ptr);
+
+	template<class TT> friend bool operator== (const shared_ptr<TT>& a, const shared_ptr<TT>& b);
+	template<class TT> friend bool operator!= (const shared_ptr<TT>& a, const shared_ptr<TT>& b);
+	template<class TT> friend bool operator<  (const shared_ptr<TT>& a, const shared_ptr<TT>& b);
+
+public:
+
+	typedef T element_type;
+
+public:
+
+	// provide a default constructor
+	shared_ptr()
+		: ptr()
+		, ctr(NULL)
+	{
+	}
+
+	// construction from an existing object of type T
+	explicit shared_ptr(T* ptr)
+		: ptr(ptr)
+		, ctr(ptr ? new detail::controller() : NULL)
+	{
+	}
+
+	shared_ptr(const shared_ptr& r)
+		: ptr(r.ptr)
+		, ctr(r.ctr ? r.ctr->incref() : NULL)
+	{
+	}
+
+	template <typename Y>
+	shared_ptr(const shared_ptr<Y>& r,typename detail::is_convertible<T,Y>::result = detail::empty())
+		: ptr(r.ptr)
+		, ctr(r.ctr ? r.ctr->incref() : NULL)
+	{
+	}
+
+	// automatic destruction of the wrapped object when all
+	// references are freed.
+	~shared_ptr()	{
+		if (ctr) {
+			ctr = ctr->decref(ptr);
+		}
+	}
+
+	shared_ptr& operator=(const shared_ptr& r) {
+		if (this == &r) {
+			return *this;
+		}
+		if (ctr) {
+			ctr->decref(ptr);
+		}
+		ptr = r.ptr;
+		ctr = ptr?r.ctr->incref():NULL;
+		return *this;
+	}
+
+	template <typename Y>
+	shared_ptr& operator=(const shared_ptr<Y>& r) {
+		if (this == &r) {
+			return *this;
+		}
+		if (ctr) {
+			ctr->decref(ptr);
+		}
+		ptr = r.ptr;
+		ctr = ptr?r.ctr->incref():NULL;
+		return *this;
+	}
+
+	// pointer access
+	inline operator T*() const {
+		return ptr;
+	}
+
+	inline T* operator-> () const	{
+		return ptr;
+	}
+
+	// standard semantics
+	inline T* get() {
+		return ptr;
+	}
+
+	inline const T* get() const	{
+		return ptr;
+	}
+
+	inline operator bool () const {
+		return ptr != NULL;
+	}
+
+	inline bool unique() const {
+		return use_count() == 1;
+	}
+
+	inline long use_count() const {
+		return ctr->get();
+	}
+
+	inline void reset (T* t = 0)	{
+		if (ctr) {
+			ctr->decref(ptr);
+		}
+		ptr = t;
+		ctr = ptr?new detail::controller():NULL;
+	}
+
+	void swap(shared_ptr & b)	{
+		std::swap(ptr, b.ptr);
+		std::swap(ctr, b.ctr);
+	}
+
+private:
+
+
+	// for use by the various xxx_pointer_cast helper templates
+	explicit shared_ptr(T* ptr, detail::controller* ctr)
+		: ptr(ptr)
+		, ctr(ctr->incref())
+	{
+	}
+
+private:
+
+	// encapsulated object pointer
+	T* ptr;
+
+	// control block
+	detail::controller* ctr;
+};
+
+template<class T>
+inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
+{
+	a.swap(b);
+}
+
+template<class T>
+bool operator== (const shared_ptr<T>& a, const shared_ptr<T>& b) {
+	return a.ptr == b.ptr;
+}
+template<class T>
+bool operator!= (const shared_ptr<T>& a, const shared_ptr<T>& b) {
+	return a.ptr != b.ptr;
+}
+	
+template<class T>
+bool operator< (const shared_ptr<T>& a, const shared_ptr<T>& b) {
+	return a.ptr < b.ptr;
+}
+
+
+template<class T, class U>
+inline shared_ptr<T> static_pointer_cast( shared_ptr<U> ptr)
+{  
+   return shared_ptr<T>(static_cast<T*>(ptr.ptr),ptr.ctr);
+}
+
+template<class T, class U>
+inline shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> ptr)
+{  
+   return shared_ptr<T>(dynamic_cast<T*>(ptr.ptr),ptr.ctr);
+}
+
+template<class T, class U>
+inline shared_ptr<T> const_pointer_cast( shared_ptr<U> ptr)
+{  
+   return shared_ptr<T>(const_cast<T*>(ptr.ptr),ptr.ctr);
+}
+
+
+
+} // end of namespace boost
+
+#else
+#	error "shared_ptr.h was already included"
+#endif
+#endif // INCLUDED_AI_BOOST_SHARED_PTR

code/BoostWorkaround/boost/timer.hpp

@@ -1,73 +1,73 @@
-//  boost timer.hpp header file  ---------------------------------------------//
-
-//  Copyright Beman Dawes 1994-99.  Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/libs/timer for documentation.
-
-//  Revision History
-//  01 Apr 01  Modified to use new <boost/limits.hpp> header. (JMaddock)
-//  12 Jan 01  Change to inline implementation to allow use without library
-//             builds. See docs for more rationale. (Beman Dawes) 
-//  25 Sep 99  elapsed_max() and elapsed_min() added (John Maddock)
-//  16 Jul 99  Second beta
-//   6 Jul 99  Initial boost version
-
-#ifndef BOOST_TIMER_HPP
-#define BOOST_TIMER_HPP
-
-//#include <boost/config.hpp>
-#include <ctime>
-#include <limits>
-//#include <boost/limits.hpp>
-
-# ifdef BOOST_NO_STDC_NAMESPACE
-    namespace std { using ::clock_t; using ::clock; }
-# endif
-
-
-namespace boost {
-
-//  timer  -------------------------------------------------------------------//
-
-//  A timer object measures elapsed time.
-
-//  It is recommended that implementations measure wall clock rather than CPU
-//  time since the intended use is performance measurement on systems where
-//  total elapsed time is more important than just process or CPU time.
-
-//  Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
-//  due to implementation limitations.  The accuracy of timings depends on the
-//  accuracy of timing information provided by the underlying platform, and
-//  this varies a great deal from platform to platform.
-
-class timer
-{
- public:
-         timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
-//         timer( const timer& src );      // post: elapsed()==src.elapsed()
-//        ~timer(){}
-//  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()
-  void   restart() { _start_time = std::clock(); } // post: elapsed()==0
-  double elapsed() const                  // return elapsed time in seconds
-    { return  double(std::clock() - _start_time) / CLOCKS_PER_SEC; }
-
-  double elapsed_max() const   // return estimated maximum value for elapsed()
-  // Portability warning: elapsed_max() may return too high a value on systems
-  // where std::clock_t overflows or resets at surprising values.
-  {
-    return (double((std::numeric_limits<std::clock_t>::max)())
-       - double(_start_time)) / double(CLOCKS_PER_SEC); 
-  }
-
-  double elapsed_min() const            // return minimum value for elapsed()
-   { return double(1)/double(CLOCKS_PER_SEC); }
-
- private:
-  std::clock_t _start_time;
-}; // timer
-
-} // namespace boost
-
-#endif  // BOOST_TIMER_HPP
+//  boost timer.hpp header file  ---------------------------------------------//
+
+//  Copyright Beman Dawes 1994-99.  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/libs/timer for documentation.
+
+//  Revision History
+//  01 Apr 01  Modified to use new <boost/limits.hpp> header. (JMaddock)
+//  12 Jan 01  Change to inline implementation to allow use without library
+//             builds. See docs for more rationale. (Beman Dawes) 
+//  25 Sep 99  elapsed_max() and elapsed_min() added (John Maddock)
+//  16 Jul 99  Second beta
+//   6 Jul 99  Initial boost version
+
+#ifndef BOOST_TIMER_HPP
+#define BOOST_TIMER_HPP
+
+//#include <boost/config.hpp>
+#include <ctime>
+#include <limits>
+//#include <boost/limits.hpp>
+
+# ifdef BOOST_NO_STDC_NAMESPACE
+    namespace std { using ::clock_t; using ::clock; }
+# endif
+
+
+namespace boost {
+
+//  timer  -------------------------------------------------------------------//
+
+//  A timer object measures elapsed time.
+
+//  It is recommended that implementations measure wall clock rather than CPU
+//  time since the intended use is performance measurement on systems where
+//  total elapsed time is more important than just process or CPU time.
+
+//  Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
+//  due to implementation limitations.  The accuracy of timings depends on the
+//  accuracy of timing information provided by the underlying platform, and
+//  this varies a great deal from platform to platform.
+
+class timer
+{
+ public:
+         timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
+//         timer( const timer& src );      // post: elapsed()==src.elapsed()
+//        ~timer(){}
+//  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()
+  void   restart() { _start_time = std::clock(); } // post: elapsed()==0
+  double elapsed() const                  // return elapsed time in seconds
+    { return  double(std::clock() - _start_time) / CLOCKS_PER_SEC; }
+
+  double elapsed_max() const   // return estimated maximum value for elapsed()
+  // Portability warning: elapsed_max() may return too high a value on systems
+  // where std::clock_t overflows or resets at surprising values.
+  {
+    return (double((std::numeric_limits<std::clock_t>::max)())
+       - double(_start_time)) / double(CLOCKS_PER_SEC); 
+  }
+
+  double elapsed_min() const            // return minimum value for elapsed()
+   { return double(1)/double(CLOCKS_PER_SEC); }
+
+ private:
+  std::clock_t _start_time;
+}; // timer
+
+} // namespace boost
+
+#endif  // BOOST_TIMER_HPP

code/ColladaParser upstream.cpp

@@ -0,0 +1,2928 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2015, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file ColladaParser.cpp
+ *  @brief Implementation of the Collada parser helper
+ */
+
+
+#ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER
+
+#include <sstream>
+#include "ColladaParser.h"
+#include "fast_atof.h"
+#include "ParsingUtils.h"
+#include <boost/scoped_ptr.hpp>
+#include <boost/foreach.hpp>
+#include "../include/assimp/DefaultLogger.hpp"
+#include "../include/assimp/IOSystem.hpp"
+#include "../include/assimp/light.h"
+
+
+using namespace Assimp;
+using namespace Assimp::Collada;
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+ColladaParser::ColladaParser( IOSystem* pIOHandler, const std::string& pFile)
+    : mFileName( pFile)
+{
+    mRootNode = NULL;
+    mUnitSize = 1.0f;
+    mUpDirection = UP_Y;
+
+    // We assume the newest file format by default
+    mFormat = FV_1_5_n;
+
+  // open the file
+  boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile));
+  if( file.get() == NULL)
+    throw DeadlyImportError( "Failed to open file " + pFile + ".");
+
+    // generate a XML reader for it
+  boost::scoped_ptr<CIrrXML_IOStreamReader> mIOWrapper( new CIrrXML_IOStreamReader( file.get()));
+    mReader = irr::io::createIrrXMLReader( mIOWrapper.get());
+    if( !mReader)
+        ThrowException( "Collada: Unable to open file.");
+
+    // start reading
+    ReadContents();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+ColladaParser::~ColladaParser()
+{
+    delete mReader;
+    for( NodeLibrary::iterator it = mNodeLibrary.begin(); it != mNodeLibrary.end(); ++it)
+        delete it->second;
+    for( MeshLibrary::iterator it = mMeshLibrary.begin(); it != mMeshLibrary.end(); ++it)
+        delete it->second;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Read bool from text contents of current element
+bool ColladaParser::ReadBoolFromTextContent()
+{
+    const char* cur = GetTextContent();
+    return (!ASSIMP_strincmp(cur,"true",4) || '0' != *cur);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Read float from text contents of current element
+float ColladaParser::ReadFloatFromTextContent()
+{
+    const char* cur = GetTextContent();
+    return fast_atof(cur);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the contents of the file
+void ColladaParser::ReadContents()
+{
+    while( mReader->read())
+    {
+        // handle the root element "COLLADA"
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "COLLADA"))
+            {
+                // check for 'version' attribute
+                const int attrib = TestAttribute("version");
+                if (attrib != -1) {
+                    const char* version = mReader->getAttributeValue(attrib);
+
+                    if (!::strncmp(version,"1.5",3)) {
+                        mFormat =  FV_1_5_n;
+                        DefaultLogger::get()->debug("Collada schema version is 1.5.n");
+                    }
+                    else if (!::strncmp(version,"1.4",3)) {
+                        mFormat =  FV_1_4_n;
+                        DefaultLogger::get()->debug("Collada schema version is 1.4.n");
+                    }
+                    else if (!::strncmp(version,"1.3",3)) {
+                        mFormat =  FV_1_3_n;
+                        DefaultLogger::get()->debug("Collada schema version is 1.3.n");
+                    }
+                }
+
+                ReadStructure();
+            } else
+            {
+                DefaultLogger::get()->debug( boost::str( boost::format( "Ignoring global element <%s>.") % mReader->getNodeName()));
+                SkipElement();
+            }
+        } else
+        {
+            // skip everything else silently
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the structure of the file
+void ColladaParser::ReadStructure()
+{
+    while( mReader->read())
+    {
+        // beginning of elements
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "asset"))
+                ReadAssetInfo();
+            else if( IsElement( "library_animations"))
+                ReadAnimationLibrary();
+            else if( IsElement( "library_controllers"))
+                ReadControllerLibrary();
+            else if( IsElement( "library_images"))
+                ReadImageLibrary();
+            else if( IsElement( "library_materials"))
+                ReadMaterialLibrary();
+            else if( IsElement( "library_effects"))
+                ReadEffectLibrary();
+            else if( IsElement( "library_geometries"))
+                ReadGeometryLibrary();
+            else if( IsElement( "library_visual_scenes"))
+                ReadSceneLibrary();
+            else if( IsElement( "library_lights"))
+                ReadLightLibrary();
+            else if( IsElement( "library_cameras"))
+                ReadCameraLibrary();
+            else if( IsElement( "library_nodes"))
+                ReadSceneNode(NULL); /* some hacking to reuse this piece of code */
+            else if( IsElement( "scene"))
+                ReadScene();
+            else
+                SkipElement();
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads asset informations such as coordinate system informations and legal blah
+void ColladaParser::ReadAssetInfo()
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "unit"))
+            {
+                // read unit data from the element's attributes
+                const int attrIndex = TestAttribute( "meter");
+                if (attrIndex == -1) {
+                    mUnitSize = 1.f;
+                }
+                else {
+                    mUnitSize = mReader->getAttributeValueAsFloat( attrIndex);
+                }
+
+                // consume the trailing stuff
+                if( !mReader->isEmptyElement())
+                    SkipElement();
+            }
+            else if( IsElement( "up_axis"))
+            {
+                // read content, strip whitespace, compare
+                const char* content = GetTextContent();
+                if( strncmp( content, "X_UP", 4) == 0)
+                    mUpDirection = UP_X;
+                else if( strncmp( content, "Z_UP", 4) == 0)
+                    mUpDirection = UP_Z;
+                else
+                    mUpDirection = UP_Y;
+
+                // check element end
+                TestClosing( "up_axis");
+            } else
+            {
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "asset") != 0)
+                ThrowException( "Expected end of <asset> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the animation library
+void ColladaParser::ReadAnimationLibrary()
+{
+    if (mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "animation"))
+            {
+                // delegate the reading. Depending on the inner elements it will be a container or a anim channel
+                ReadAnimation( &mAnims);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "library_animations") != 0)
+                ThrowException( "Expected end of <library_animations> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an animation into the given parent structure
+void ColladaParser::ReadAnimation( Collada::Animation* pParent)
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    // an <animation> element may be a container for grouping sub-elements or an animation channel
+    // this is the channel collection by ID, in case it has channels
+    typedef std::map<std::string, AnimationChannel> ChannelMap;
+    ChannelMap channels;
+    // this is the anim container in case we're a container
+    Animation* anim = NULL;
+
+    // optional name given as an attribute
+    std::string animName;
+    int indexName = TestAttribute( "name");
+    int indexID = TestAttribute( "id");
+    if( indexName >= 0)
+        animName = mReader->getAttributeValue( indexName);
+    else if( indexID >= 0)
+        animName = mReader->getAttributeValue( indexID);
+    else
+        animName = "animation";
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            // we have subanimations
+            if( IsElement( "animation"))
+            {
+                // create container from our element
+                if( !anim)
+                {
+                    anim = new Animation;
+                    anim->mName = animName;
+                    pParent->mSubAnims.push_back( anim);
+                }
+
+                // recurse into the subelement
+                ReadAnimation( anim);
+            }
+            else if( IsElement( "source"))
+            {
+                // possible animation data - we'll never know. Better store it
+                ReadSource();
+            }
+            else if( IsElement( "sampler"))
+            {
+                // read the ID to assign the corresponding collada channel afterwards.
+                int indexID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( indexID);
+                ChannelMap::iterator newChannel = channels.insert( std::make_pair( id, AnimationChannel())).first;
+
+                // have it read into a channel
+                ReadAnimationSampler( newChannel->second);
+            }
+            else if( IsElement( "channel"))
+            {
+                // the binding element whose whole purpose is to provide the target to animate
+                // Thanks, Collada! A directly posted information would have been too simple, I guess.
+                // Better add another indirection to that! Can't have enough of those.
+                int indexTarget = GetAttribute( "target");
+                int indexSource = GetAttribute( "source");
+                const char* sourceId = mReader->getAttributeValue( indexSource);
+                if( sourceId[0] == '#')
+                    sourceId++;
+                ChannelMap::iterator cit = channels.find( sourceId);
+                if( cit != channels.end())
+                    cit->second.mTarget = mReader->getAttributeValue( indexTarget);
+
+                if( !mReader->isEmptyElement())
+                    SkipElement();
+            }
+            else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "animation") != 0)
+                ThrowException( "Expected end of <animation> element.");
+
+            break;
+        }
+    }
+
+    // it turned out to have channels - add them
+    if( !channels.empty())
+    {
+        // special filtering for stupid exporters packing each channel into a separate animation
+        if( channels.size() == 1)
+        {
+            pParent->mChannels.push_back( channels.begin()->second);
+        } else
+        {
+            // else create the animation, if not done yet, and store the channels
+            if( !anim)
+            {
+                anim = new Animation;
+                anim->mName = animName;
+                pParent->mSubAnims.push_back( anim);
+            }
+            for( ChannelMap::const_iterator it = channels.begin(); it != channels.end(); ++it)
+                anim->mChannels.push_back( it->second);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an animation sampler into the given anim channel
+void ColladaParser::ReadAnimationSampler( Collada::AnimationChannel& pChannel)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "input"))
+            {
+                int indexSemantic = GetAttribute( "semantic");
+                const char* semantic = mReader->getAttributeValue( indexSemantic);
+                int indexSource = GetAttribute( "source");
+                const char* source = mReader->getAttributeValue( indexSource);
+                if( source[0] != '#')
+                    ThrowException( "Unsupported URL format");
+                source++;
+
+                if( strcmp( semantic, "INPUT") == 0)
+                    pChannel.mSourceTimes = source;
+                else if( strcmp( semantic, "OUTPUT") == 0)
+                    pChannel.mSourceValues = source;
+
+                if( !mReader->isEmptyElement())
+                    SkipElement();
+            }
+            else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "sampler") != 0)
+                ThrowException( "Expected end of <sampler> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the skeleton controller library
+void ColladaParser::ReadControllerLibrary()
+{
+    if (mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "controller"))
+            {
+                // read ID. Ask the spec if it's neccessary or optional... you might be surprised.
+                int attrID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( attrID);
+
+                // create an entry and store it in the library under its ID
+                mControllerLibrary[id] = Controller();
+
+                // read on from there
+                ReadController( mControllerLibrary[id]);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "library_controllers") != 0)
+                ThrowException( "Expected end of <library_controllers> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a controller into the given mesh structure
+void ColladaParser::ReadController( Collada::Controller& pController)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            // two types of controllers: "skin" and "morph". Only the first one is relevant, we skip the other
+            if( IsElement( "morph"))
+            {
+                // should skip everything inside, so there's no danger of catching elements inbetween
+                SkipElement();
+            }
+            else if( IsElement( "skin"))
+            {
+                // read the mesh it refers to. According to the spec this could also be another
+                // controller, but I refuse to implement every single idea they've come up with
+                int sourceIndex = GetAttribute( "source");
+                pController.mMeshId = mReader->getAttributeValue( sourceIndex) + 1;
+            }
+            else if( IsElement( "bind_shape_matrix"))
+            {
+                // content is 16 floats to define a matrix... it seems to be important for some models
+          const char* content = GetTextContent();
+
+          // read the 16 floats
+          for( unsigned int a = 0; a < 16; a++)
+          {
+              // read a number
+          content = fast_atoreal_move<float>( content, pController.mBindShapeMatrix[a]);
+              // skip whitespace after it
+              SkipSpacesAndLineEnd( &content);
+          }
+
+        TestClosing( "bind_shape_matrix");
+            }
+            else if( IsElement( "source"))
+            {
+                // data array - we have specialists to handle this
+                ReadSource();
+            }
+            else if( IsElement( "joints"))
+            {
+                ReadControllerJoints( pController);
+            }
+            else if( IsElement( "vertex_weights"))
+            {
+                ReadControllerWeights( pController);
+            }
+            else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "controller") == 0)
+                break;
+            else if( strcmp( mReader->getNodeName(), "skin") != 0)
+                ThrowException( "Expected end of <controller> element.");
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the joint definitions for the given controller
+void ColladaParser::ReadControllerJoints( Collada::Controller& pController)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            // Input channels for joint data. Two possible semantics: "JOINT" and "INV_BIND_MATRIX"
+            if( IsElement( "input"))
+            {
+                int indexSemantic = GetAttribute( "semantic");
+                const char* attrSemantic = mReader->getAttributeValue( indexSemantic);
+                int indexSource = GetAttribute( "source");
+                const char* attrSource = mReader->getAttributeValue( indexSource);
+
+                // local URLS always start with a '#'. We don't support global URLs
+                if( attrSource[0] != '#')
+                    ThrowException( boost::str( boost::format( "Unsupported URL format in \"%s\" in source attribute of <joints> data <input> element") % attrSource));
+                attrSource++;
+
+                // parse source URL to corresponding source
+                if( strcmp( attrSemantic, "JOINT") == 0)
+                    pController.mJointNameSource = attrSource;
+                else if( strcmp( attrSemantic, "INV_BIND_MATRIX") == 0)
+                    pController.mJointOffsetMatrixSource = attrSource;
+                else
+                    ThrowException( boost::str( boost::format( "Unknown semantic \"%s\" in <joints> data <input> element") % attrSemantic));
+
+                // skip inner data, if present
+                if( !mReader->isEmptyElement())
+                    SkipElement();
+            }
+            else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "joints") != 0)
+                ThrowException( "Expected end of <joints> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the joint weights for the given controller
+void ColladaParser::ReadControllerWeights( Collada::Controller& pController)
+{
+    // read vertex count from attributes and resize the array accordingly
+    int indexCount = GetAttribute( "count");
+    size_t vertexCount = (size_t) mReader->getAttributeValueAsInt( indexCount);
+    pController.mWeightCounts.resize( vertexCount);
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            // Input channels for weight data. Two possible semantics: "JOINT" and "WEIGHT"
+            if( IsElement( "input") && vertexCount > 0 )
+            {
+                InputChannel channel;
+
+                int indexSemantic = GetAttribute( "semantic");
+                const char* attrSemantic = mReader->getAttributeValue( indexSemantic);
+                int indexSource = GetAttribute( "source");
+                const char* attrSource = mReader->getAttributeValue( indexSource);
+                int indexOffset = TestAttribute( "offset");
+                if( indexOffset >= 0)
+                    channel.mOffset = mReader->getAttributeValueAsInt( indexOffset);
+
+                // local URLS always start with a '#'. We don't support global URLs
+                if( attrSource[0] != '#')
+                    ThrowException( boost::str( boost::format( "Unsupported URL format in \"%s\" in source attribute of <vertex_weights> data <input> element") % attrSource));
+                channel.mAccessor = attrSource + 1;
+
+                // parse source URL to corresponding source
+                if( strcmp( attrSemantic, "JOINT") == 0)
+                    pController.mWeightInputJoints = channel;
+                else if( strcmp( attrSemantic, "WEIGHT") == 0)
+                    pController.mWeightInputWeights = channel;
+                else
+                    ThrowException( boost::str( boost::format( "Unknown semantic \"%s\" in <vertex_weights> data <input> element") % attrSemantic));
+
+                // skip inner data, if present
+                if( !mReader->isEmptyElement())
+                    SkipElement();
+            }
+            else if( IsElement( "vcount") && vertexCount > 0 )
+            {
+                // read weight count per vertex
+                const char* text = GetTextContent();
+                size_t numWeights = 0;
+                for( std::vector<size_t>::iterator it = pController.mWeightCounts.begin(); it != pController.mWeightCounts.end(); ++it)
+                {
+                    if( *text == 0)
+                        ThrowException( "Out of data while reading <vcount>");
+
+                    *it = strtoul10( text, &text);
+                    numWeights += *it;
+                    SkipSpacesAndLineEnd( &text);
+                }
+
+                TestClosing( "vcount");
+
+                // reserve weight count
+                pController.mWeights.resize( numWeights);
+            }
+            else if( IsElement( "v") && vertexCount > 0 )
+            {
+                // read JointIndex - WeightIndex pairs
+                const char* text = GetTextContent();
+
+                for( std::vector< std::pair<size_t, size_t> >::iterator it = pController.mWeights.begin(); it != pController.mWeights.end(); ++it)
+                {
+                    if( *text == 0)
+                        ThrowException( "Out of data while reading <vertex_weights>");
+                    it->first = strtoul10( text, &text);
+                    SkipSpacesAndLineEnd( &text);
+                    if( *text == 0)
+                        ThrowException( "Out of data while reading <vertex_weights>");
+                    it->second = strtoul10( text, &text);
+                    SkipSpacesAndLineEnd( &text);
+                }
+
+                TestClosing( "v");
+            }
+            else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "vertex_weights") != 0)
+                ThrowException( "Expected end of <vertex_weights> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the image library contents
+void ColladaParser::ReadImageLibrary()
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if( IsElement( "image"))
+            {
+                // read ID. Another entry which is "optional" by design but obligatory in reality
+                int attrID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( attrID);
+
+                // create an entry and store it in the library under its ID
+                mImageLibrary[id] = Image();
+
+                // read on from there
+                ReadImage( mImageLibrary[id]);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "library_images") != 0)
+                ThrowException( "Expected end of <library_images> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an image entry into the given image
+void ColladaParser::ReadImage( Collada::Image& pImage)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT){
+            // Need to run different code paths here, depending on the Collada XSD version
+            if (IsElement("image")) {
+                SkipElement();
+            }
+            else if(  IsElement( "init_from"))
+            {
+                if (mFormat == FV_1_4_n)
+                {
+                    // FIX: C4D exporter writes empty <init_from/> tags
+                    if (!mReader->isEmptyElement()) {
+                        // element content is filename - hopefully
+                        const char* sz = TestTextContent();
+                        if (sz)pImage.mFileName = sz;
+                        TestClosing( "init_from");
+                    }
+                    if (!pImage.mFileName.length()) {
+                        pImage.mFileName = "unknown_texture";
+                    }
+                }
+                else if (mFormat == FV_1_5_n)
+                {
+                    // make sure we skip over mip and array initializations, which
+                    // we don't support, but which could confuse the loader if
+                    // they're not skipped.
+                    int attrib = TestAttribute("array_index");
+                    if (attrib != -1 && mReader->getAttributeValueAsInt(attrib) > 0) {
+                        DefaultLogger::get()->warn("Collada: Ignoring texture array index");
+                        continue;
+                    }
+
+                    attrib = TestAttribute("mip_index");
+                    if (attrib != -1 && mReader->getAttributeValueAsInt(attrib) > 0) {
+                        DefaultLogger::get()->warn("Collada: Ignoring MIP map layer");
+                        continue;
+                    }
+
+                    // TODO: correctly jump over cube and volume maps?
+                }
+            }
+            else if (mFormat == FV_1_5_n)
+            {
+                if( IsElement( "ref"))
+                {
+                    // element content is filename - hopefully
+                    const char* sz = TestTextContent();
+                    if (sz)pImage.mFileName = sz;
+                    TestClosing( "ref");
+                }
+                else if( IsElement( "hex") && !pImage.mFileName.length())
+                {
+                    // embedded image. get format
+                    const int attrib = TestAttribute("format");
+                    if (-1 == attrib)
+                        DefaultLogger::get()->warn("Collada: Unknown image file format");
+                    else pImage.mEmbeddedFormat = mReader->getAttributeValue(attrib);
+
+                    const char* data = GetTextContent();
+
+                    // hexadecimal-encoded binary octets. First of all, find the
+                    // required buffer size to reserve enough storage.
+                    const char* cur = data;
+                    while (!IsSpaceOrNewLine(*cur)) cur++;
+
+                    const unsigned int size = (unsigned int)(cur-data) * 2;
+                    pImage.mImageData.resize(size);
+                    for (unsigned int i = 0; i < size;++i)
+                        pImage.mImageData[i] = HexOctetToDecimal(data+(i<<1));
+
+                    TestClosing( "hex");
+                }
+            }
+            else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "image") == 0)
+                break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the material library
+void ColladaParser::ReadMaterialLibrary()
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    std::map<std::string, int> names;
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "material"))
+            {
+                // read ID. By now you propably know my opinion about this "specification"
+                int attrID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( attrID);
+
+                std::string name;
+                int attrName = TestAttribute("name");
+                if (attrName >= 0)
+                    name = mReader->getAttributeValue( attrName);
+
+                // create an entry and store it in the library under its ID
+                mMaterialLibrary[id] = Material();
+
+                if( !name.empty())
+                {
+                    std::map<std::string, int>::iterator it = names.find( name);
+                    if( it != names.end())
+                    {
+                        std::ostringstream strStream;
+                        strStream << ++it->second;
+                        name.append( " " + strStream.str());
+                    }
+                    else
+                    {
+                        names[name] = 0;
+                    }
+
+                    mMaterialLibrary[id].mName = name;
+                }
+
+                ReadMaterial( mMaterialLibrary[id]);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "library_materials") != 0)
+                ThrowException( "Expected end of <library_materials> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the light library
+void ColladaParser::ReadLightLibrary()
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if( IsElement( "light"))
+            {
+                // read ID. By now you propably know my opinion about this "specification"
+                int attrID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( attrID);
+
+                // create an entry and store it in the library under its ID
+                ReadLight(mLightLibrary[id] = Light());
+
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)    {
+            if( strcmp( mReader->getNodeName(), "library_lights") != 0)
+                ThrowException( "Expected end of <library_lights> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the camera library
+void ColladaParser::ReadCameraLibrary()
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if( IsElement( "camera"))
+            {
+                // read ID. By now you propably know my opinion about this "specification"
+                int attrID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( attrID);
+
+                // create an entry and store it in the library under its ID
+                Camera& cam = mCameraLibrary[id];
+                attrID = TestAttribute( "name");
+                if (attrID != -1)
+                    cam.mName = mReader->getAttributeValue( attrID);
+
+                ReadCamera(cam);
+
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)    {
+            if( strcmp( mReader->getNodeName(), "library_cameras") != 0)
+                ThrowException( "Expected end of <library_cameras> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a material entry into the given material
+void ColladaParser::ReadMaterial( Collada::Material& pMaterial)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if (IsElement("material")) {
+                SkipElement();
+            }
+            else if( IsElement( "instance_effect"))
+            {
+                // referred effect by URL
+                int attrUrl = GetAttribute( "url");
+                const char* url = mReader->getAttributeValue( attrUrl);
+                if( url[0] != '#')
+                    ThrowException( "Unknown reference format");
+
+                pMaterial.mEffect = url+1;
+
+                SkipElement();
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "material") != 0)
+                ThrowException( "Expected end of <material> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a light entry into the given light
+void ColladaParser::ReadLight( Collada::Light& pLight)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if (IsElement("light")) {
+                SkipElement();
+            }
+            else if (IsElement("spot")) {
+                pLight.mType = aiLightSource_SPOT;
+            }
+            else if (IsElement("ambient")) {
+                pLight.mType = aiLightSource_AMBIENT;
+            }
+            else if (IsElement("directional")) {
+                pLight.mType = aiLightSource_DIRECTIONAL;
+            }
+            else if (IsElement("point")) {
+                pLight.mType = aiLightSource_POINT;
+            }
+            else if (IsElement("color")) {
+                // text content contains 3 floats
+                const char* content = GetTextContent();
+
+                content = fast_atoreal_move<float>( content, (float&)pLight.mColor.r);
+                SkipSpacesAndLineEnd( &content);
+
+                content = fast_atoreal_move<float>( content, (float&)pLight.mColor.g);
+                SkipSpacesAndLineEnd( &content);
+
+                content = fast_atoreal_move<float>( content, (float&)pLight.mColor.b);
+                SkipSpacesAndLineEnd( &content);
+
+                TestClosing( "color");
+            }
+            else if (IsElement("constant_attenuation")) {
+                pLight.mAttConstant = ReadFloatFromTextContent();
+                TestClosing("constant_attenuation");
+            }
+            else if (IsElement("linear_attenuation")) {
+                pLight.mAttLinear = ReadFloatFromTextContent();
+                TestClosing("linear_attenuation");
+            }
+            else if (IsElement("quadratic_attenuation")) {
+                pLight.mAttQuadratic = ReadFloatFromTextContent();
+                TestClosing("quadratic_attenuation");
+            }
+            else if (IsElement("falloff_angle")) {
+                pLight.mFalloffAngle = ReadFloatFromTextContent();
+                TestClosing("falloff_angle");
+            }
+            else if (IsElement("falloff_exponent")) {
+                pLight.mFalloffExponent = ReadFloatFromTextContent();
+                TestClosing("falloff_exponent");
+            }
+            // FCOLLADA extensions
+            // -------------------------------------------------------
+            else if (IsElement("outer_cone")) {
+                pLight.mOuterAngle = ReadFloatFromTextContent();
+                TestClosing("outer_cone");
+            }
+            // ... and this one is even deprecated
+            else if (IsElement("penumbra_angle")) {
+                pLight.mPenumbraAngle = ReadFloatFromTextContent();
+                TestClosing("penumbra_angle");
+            }
+            else if (IsElement("intensity")) {
+                pLight.mIntensity = ReadFloatFromTextContent();
+                TestClosing("intensity");
+            }
+            else if (IsElement("falloff")) {
+                pLight.mOuterAngle = ReadFloatFromTextContent();
+                TestClosing("falloff");
+            }
+            else if (IsElement("hotspot_beam")) {
+                pLight.mFalloffAngle = ReadFloatFromTextContent();
+                TestClosing("hotspot_beam");
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "light") == 0)
+                break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a camera entry into the given light
+void ColladaParser::ReadCamera( Collada::Camera& pCamera)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if (IsElement("camera")) {
+                SkipElement();
+            }
+            else if (IsElement("orthographic")) {
+                pCamera.mOrtho = true;
+            }
+            else if (IsElement("xfov") || IsElement("xmag")) {
+                pCamera.mHorFov = ReadFloatFromTextContent();
+                TestClosing((pCamera.mOrtho ? "xmag" : "xfov"));
+            }
+            else if (IsElement("yfov") || IsElement("ymag")) {
+                pCamera.mVerFov = ReadFloatFromTextContent();
+                TestClosing((pCamera.mOrtho ? "ymag" : "yfov"));
+            }
+            else if (IsElement("aspect_ratio")) {
+                pCamera.mAspect = ReadFloatFromTextContent();
+                TestClosing("aspect_ratio");
+            }
+            else if (IsElement("znear")) {
+                pCamera.mZNear = ReadFloatFromTextContent();
+                TestClosing("znear");
+            }
+            else if (IsElement("zfar")) {
+                pCamera.mZFar = ReadFloatFromTextContent();
+                TestClosing("zfar");
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "camera") == 0)
+                break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the effect library
+void ColladaParser::ReadEffectLibrary()
+{
+    if (mReader->isEmptyElement()) {
+        return;
+    }
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if( IsElement( "effect"))
+            {
+                // read ID. Do I have to repeat my ranting about "optional" attributes?
+                int attrID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( attrID);
+
+                // create an entry and store it in the library under its ID
+                mEffectLibrary[id] = Effect();
+                // read on from there
+                ReadEffect( mEffectLibrary[id]);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "library_effects") != 0)
+                ThrowException( "Expected end of <library_effects> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect entry into the given effect
+void ColladaParser::ReadEffect( Collada::Effect& pEffect)
+{
+    // for the moment we don't support any other type of effect.
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "profile_COMMON"))
+                ReadEffectProfileCommon( pEffect);
+            else
+                SkipElement();
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "effect") != 0)
+                ThrowException( "Expected end of <effect> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an COMMON effect profile
+void ColladaParser::ReadEffectProfileCommon( Collada::Effect& pEffect)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "newparam")) {
+                // save ID
+                int attrSID = GetAttribute( "sid");
+                std::string sid = mReader->getAttributeValue( attrSID);
+                pEffect.mParams[sid] = EffectParam();
+                ReadEffectParam( pEffect.mParams[sid]);
+            }
+            else if( IsElement( "technique") || IsElement( "extra"))
+            {
+                // just syntactic sugar
+            }
+
+            else if( mFormat == FV_1_4_n && IsElement( "image"))
+            {
+                // read ID. Another entry which is "optional" by design but obligatory in reality
+                int attrID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( attrID);
+
+                // create an entry and store it in the library under its ID
+                mImageLibrary[id] = Image();
+
+                // read on from there
+                ReadImage( mImageLibrary[id]);
+            }
+
+            /* Shading modes */
+            else if( IsElement( "phong"))
+                pEffect.mShadeType = Shade_Phong;
+            else if( IsElement( "constant"))
+                pEffect.mShadeType = Shade_Constant;
+            else if( IsElement( "lambert"))
+                pEffect.mShadeType = Shade_Lambert;
+            else if( IsElement( "blinn"))
+                pEffect.mShadeType = Shade_Blinn;
+
+            /* Color + texture properties */
+            else if( IsElement( "emission"))
+                ReadEffectColor( pEffect.mEmissive, pEffect.mTexEmissive);
+            else if( IsElement( "ambient"))
+                ReadEffectColor( pEffect.mAmbient, pEffect.mTexAmbient);
+            else if( IsElement( "diffuse"))
+                ReadEffectColor( pEffect.mDiffuse, pEffect.mTexDiffuse);
+            else if( IsElement( "specular"))
+                ReadEffectColor( pEffect.mSpecular, pEffect.mTexSpecular);
+            else if( IsElement( "reflective")) {
+                ReadEffectColor( pEffect.mReflective, pEffect.mTexReflective);
+            }
+            else if( IsElement( "transparent")) {
+                pEffect.mHasTransparency = true;
+
+                // In RGB_ZERO mode, the transparency is interpreted in reverse, go figure...
+                if(::strcmp(mReader->getAttributeValueSafe("opaque"), "RGB_ZERO") == 0) {
+                    // TODO: handle RGB_ZERO mode completely
+                    pEffect.mRGBTransparency = true;
+                }
+
+                ReadEffectColor( pEffect.mTransparent,pEffect.mTexTransparent);
+            }
+            else if( IsElement( "shininess"))
+                ReadEffectFloat( pEffect.mShininess);
+            else if( IsElement( "reflectivity"))
+                ReadEffectFloat( pEffect.mReflectivity);
+
+            /* Single scalar properties */
+            else if( IsElement( "transparency"))
+                ReadEffectFloat( pEffect.mTransparency);
+            else if( IsElement( "index_of_refraction"))
+                ReadEffectFloat( pEffect.mRefractIndex);
+
+            // GOOGLEEARTH/OKINO extensions
+            // -------------------------------------------------------
+            else if( IsElement( "double_sided"))
+                pEffect.mDoubleSided = ReadBoolFromTextContent();
+
+            // FCOLLADA extensions
+            // -------------------------------------------------------
+            else if( IsElement( "bump")) {
+                aiColor4D dummy;
+                ReadEffectColor( dummy,pEffect.mTexBump);
+            }
+
+            // MAX3D extensions
+            // -------------------------------------------------------
+            else if( IsElement( "wireframe"))   {
+                pEffect.mWireframe = ReadBoolFromTextContent();
+                TestClosing( "wireframe");
+            }
+            else if( IsElement( "faceted")) {
+                pEffect.mFaceted = ReadBoolFromTextContent();
+                TestClosing( "faceted");
+            }
+            else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "profile_COMMON") == 0)
+            {
+                break;
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Read texture wrapping + UV transform settings from a profile==Maya chunk
+void ColladaParser::ReadSamplerProperties( Sampler& out )
+{
+    if (mReader->isEmptyElement()) {
+        return;
+    }
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+
+            // MAYA extensions
+            // -------------------------------------------------------
+            if( IsElement( "wrapU"))        {
+                out.mWrapU = ReadBoolFromTextContent();
+                TestClosing( "wrapU");
+            }
+            else if( IsElement( "wrapV"))   {
+                out.mWrapV = ReadBoolFromTextContent();
+                TestClosing( "wrapV");
+            }
+            else if( IsElement( "mirrorU"))     {
+                out.mMirrorU = ReadBoolFromTextContent();
+                TestClosing( "mirrorU");
+            }
+            else if( IsElement( "mirrorV")) {
+                out.mMirrorV = ReadBoolFromTextContent();
+                TestClosing( "mirrorV");
+            }
+            else if( IsElement( "repeatU")) {
+                out.mTransform.mScaling.x = ReadFloatFromTextContent();
+                TestClosing( "repeatU");
+            }
+            else if( IsElement( "repeatV")) {
+                out.mTransform.mScaling.y = ReadFloatFromTextContent();
+                TestClosing( "repeatV");
+            }
+            else if( IsElement( "offsetU")) {
+                out.mTransform.mTranslation.x = ReadFloatFromTextContent();
+                TestClosing( "offsetU");
+            }
+            else if( IsElement( "offsetV")) {
+                out.mTransform.mTranslation.y = ReadFloatFromTextContent();
+                TestClosing( "offsetV");
+            }
+            else if( IsElement( "rotateUV"))    {
+                out.mTransform.mRotation = ReadFloatFromTextContent();
+                TestClosing( "rotateUV");
+            }
+            else if( IsElement( "blend_mode"))  {
+
+                const char* sz = GetTextContent();
+                // http://www.feelingsoftware.com/content/view/55/72/lang,en/
+                // NONE, OVER, IN, OUT, ADD, SUBTRACT, MULTIPLY, DIFFERENCE, LIGHTEN, DARKEN, SATURATE, DESATURATE and ILLUMINATE
+                if (0 == ASSIMP_strincmp(sz,"ADD",3))
+                    out.mOp = aiTextureOp_Add;
+
+                else if (0 == ASSIMP_strincmp(sz,"SUBTRACT",8))
+                    out.mOp = aiTextureOp_Subtract;
+
+                else if (0 == ASSIMP_strincmp(sz,"MULTIPLY",8))
+                    out.mOp = aiTextureOp_Multiply;
+
+                else  {
+                    DefaultLogger::get()->warn("Collada: Unsupported MAYA texture blend mode");
+                }
+                TestClosing( "blend_mode");
+            }
+            // OKINO extensions
+            // -------------------------------------------------------
+            else if( IsElement( "weighting"))   {
+                out.mWeighting = ReadFloatFromTextContent();
+                TestClosing( "weighting");
+            }
+            else if( IsElement( "mix_with_previous_layer")) {
+                out.mMixWithPrevious = ReadFloatFromTextContent();
+                TestClosing( "mix_with_previous_layer");
+            }
+            // MAX3D extensions
+            // -------------------------------------------------------
+            else if( IsElement( "amount"))  {
+                out.mWeighting = ReadFloatFromTextContent();
+                TestClosing( "amount");
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "technique") == 0)
+                break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect entry containing a color or a texture defining that color
+void ColladaParser::ReadEffectColor( aiColor4D& pColor, Sampler& pSampler)
+{
+    if (mReader->isEmptyElement())
+        return;
+
+    // Save current element name
+    const std::string curElem = mReader->getNodeName();
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if( IsElement( "color"))
+            {
+                // text content contains 4 floats
+                const char* content = GetTextContent();
+
+                content = fast_atoreal_move<float>( content, (float&)pColor.r);
+                SkipSpacesAndLineEnd( &content);
+
+                content = fast_atoreal_move<float>( content, (float&)pColor.g);
+                SkipSpacesAndLineEnd( &content);
+
+                content = fast_atoreal_move<float>( content, (float&)pColor.b);
+                SkipSpacesAndLineEnd( &content);
+
+                content = fast_atoreal_move<float>( content, (float&)pColor.a);
+                SkipSpacesAndLineEnd( &content);
+                TestClosing( "color");
+            }
+            else if( IsElement( "texture"))
+            {
+                // get name of source textur/sampler
+                int attrTex = GetAttribute( "texture");
+                pSampler.mName = mReader->getAttributeValue( attrTex);
+
+                // get name of UV source channel. Specification demands it to be there, but some exporters
+                // don't write it. It will be the default UV channel in case it's missing.
+                attrTex = TestAttribute( "texcoord");
+                if( attrTex >= 0 )
+                    pSampler.mUVChannel = mReader->getAttributeValue( attrTex);
+                //SkipElement();
+
+                // as we've read texture, the color needs to be 1,1,1,1
+                pColor = aiColor4D(1.f, 1.f, 1.f, 1.f);
+            }
+            else if( IsElement( "technique"))
+            {
+                const int _profile = GetAttribute( "profile");
+                const char* profile = mReader->getAttributeValue( _profile );
+
+                // Some extensions are quite useful ... ReadSamplerProperties processes
+                // several extensions in MAYA, OKINO and MAX3D profiles.
+                if (!::strcmp(profile,"MAYA") || !::strcmp(profile,"MAX3D") || !::strcmp(profile,"OKINO"))
+                {
+                    // get more information on this sampler
+                    ReadSamplerProperties(pSampler);
+                }
+                else SkipElement();
+            }
+            else if( !IsElement( "extra"))
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END){
+            if (mReader->getNodeName() == curElem)
+                break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect entry containing a float
+void ColladaParser::ReadEffectFloat( float& pFloat)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT){
+            if( IsElement( "float"))
+            {
+                // text content contains a single floats
+                const char* content = GetTextContent();
+                content = fast_atoreal_move<float>( content, pFloat);
+                SkipSpacesAndLineEnd( &content);
+
+                TestClosing( "float");
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END){
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect parameter specification of any kind
+void ColladaParser::ReadEffectParam( Collada::EffectParam& pParam)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if( IsElement( "surface"))
+            {
+                // image ID given inside <init_from> tags
+                TestOpening( "init_from");
+                const char* content = GetTextContent();
+                pParam.mType = Param_Surface;
+                pParam.mReference = content;
+                TestClosing( "init_from");
+
+                // don't care for remaining stuff
+                SkipElement( "surface");
+            }
+            else if( IsElement( "sampler2D"))
+            {
+                // surface ID is given inside <source> tags
+                TestOpening( "source");
+                const char* content = GetTextContent();
+                pParam.mType = Param_Sampler;
+                pParam.mReference = content;
+                TestClosing( "source");
+
+                // don't care for remaining stuff
+                SkipElement( "sampler2D");
+            } else
+            {
+                // ignore unknown element
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the geometry library contents
+void ColladaParser::ReadGeometryLibrary()
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "geometry"))
+            {
+                // read ID. Another entry which is "optional" by design but obligatory in reality
+                int indexID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( indexID);
+
+                // TODO: (thom) support SIDs
+                // ai_assert( TestAttribute( "sid") == -1);
+
+                // create a mesh and store it in the library under its ID
+                Mesh* mesh = new Mesh;
+                mMeshLibrary[id] = mesh;
+
+                // read the mesh name if it exists
+                const int nameIndex = TestAttribute("name");
+                if(nameIndex != -1)
+                {
+                    mesh->mName = mReader->getAttributeValue(nameIndex);
+                }
+
+                // read on from there
+                ReadGeometry( mesh);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "library_geometries") != 0)
+                ThrowException( "Expected end of <library_geometries> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a geometry from the geometry library.
+void ColladaParser::ReadGeometry( Collada::Mesh* pMesh)
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "mesh"))
+            {
+                // read on from there
+                ReadMesh( pMesh);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "geometry") != 0)
+                ThrowException( "Expected end of <geometry> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a mesh from the geometry library
+void ColladaParser::ReadMesh( Mesh* pMesh)
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "source"))
+            {
+                // we have professionals dealing with this
+                ReadSource();
+            }
+            else if( IsElement( "vertices"))
+            {
+                // read per-vertex mesh data
+                ReadVertexData( pMesh);
+            }
+            else if( IsElement( "triangles") || IsElement( "lines") || IsElement( "linestrips")
+                || IsElement( "polygons") || IsElement( "polylist") || IsElement( "trifans") || IsElement( "tristrips"))
+            {
+                // read per-index mesh data and faces setup
+                ReadIndexData( pMesh);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "technique_common") == 0)
+            {
+                // end of another meaningless element - read over it
+            }
+            else if( strcmp( mReader->getNodeName(), "mesh") == 0)
+            {
+                // end of <mesh> element - we're done here
+                break;
+            } else
+            {
+                // everything else should be punished
+                ThrowException( "Expected end of <mesh> element.");
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a source element
+void ColladaParser::ReadSource()
+{
+    int indexID = GetAttribute( "id");
+    std::string sourceID = mReader->getAttributeValue( indexID);
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "float_array") || IsElement( "IDREF_array") || IsElement( "Name_array"))
+            {
+                ReadDataArray();
+            }
+            else if( IsElement( "technique_common"))
+            {
+                // I don't care for your profiles
+            }
+            else if( IsElement( "accessor"))
+            {
+                ReadAccessor( sourceID);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "source") == 0)
+            {
+                // end of <source> - we're done
+                break;
+            }
+            else if( strcmp( mReader->getNodeName(), "technique_common") == 0)
+            {
+                // end of another meaningless element - read over it
+            } else
+            {
+                // everything else should be punished
+                ThrowException( "Expected end of <source> element.");
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a data array holding a number of floats, and stores it in the global library
+void ColladaParser::ReadDataArray()
+{
+    std::string elmName = mReader->getNodeName();
+    bool isStringArray = (elmName == "IDREF_array" || elmName == "Name_array");
+  bool isEmptyElement = mReader->isEmptyElement();
+
+    // read attributes
+    int indexID = GetAttribute( "id");
+    std::string id = mReader->getAttributeValue( indexID);
+    int indexCount = GetAttribute( "count");
+    unsigned int count = (unsigned int) mReader->getAttributeValueAsInt( indexCount);
+    const char* content = TestTextContent();
+
+  // read values and store inside an array in the data library
+  mDataLibrary[id] = Data();
+  Data& data = mDataLibrary[id];
+  data.mIsStringArray = isStringArray;
+
+  // some exporters write empty data arrays, but we need to conserve them anyways because others might reference them
+  if (content)
+  {
+        if( isStringArray)
+        {
+            data.mStrings.reserve( count);
+            std::string s;
+
+            for( unsigned int a = 0; a < count; a++)
+            {
+                if( *content == 0)
+                    ThrowException( "Expected more values while reading IDREF_array contents.");
+
+                s.clear();
+                while( !IsSpaceOrNewLine( *content))
+                    s += *content++;
+                data.mStrings.push_back( s);
+
+                SkipSpacesAndLineEnd( &content);
+            }
+        } else
+        {
+            data.mValues.reserve( count);
+
+            for( unsigned int a = 0; a < count; a++)
+            {
+                if( *content == 0)
+                    ThrowException( "Expected more values while reading float_array contents.");
+
+                float value;
+                // read a number
+                content = fast_atoreal_move<float>( content, value);
+                data.mValues.push_back( value);
+                // skip whitespace after it
+                SkipSpacesAndLineEnd( &content);
+            }
+        }
+    }
+
+  // test for closing tag
+  if( !isEmptyElement )
+    TestClosing( elmName.c_str());
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an accessor and stores it in the global library
+void ColladaParser::ReadAccessor( const std::string& pID)
+{
+    // read accessor attributes
+    int attrSource = GetAttribute( "source");
+    const char* source = mReader->getAttributeValue( attrSource);
+    if( source[0] != '#')
+        ThrowException( boost::str( boost::format( "Unknown reference format in url \"%s\" in source attribute of <accessor> element.") % source));
+    int attrCount = GetAttribute( "count");
+    unsigned int count = (unsigned int) mReader->getAttributeValueAsInt( attrCount);
+    int attrOffset = TestAttribute( "offset");
+    unsigned int offset = 0;
+    if( attrOffset > -1)
+        offset = (unsigned int) mReader->getAttributeValueAsInt( attrOffset);
+    int attrStride = TestAttribute( "stride");
+    unsigned int stride = 1;
+    if( attrStride > -1)
+        stride = (unsigned int) mReader->getAttributeValueAsInt( attrStride);
+
+    // store in the library under the given ID
+    mAccessorLibrary[pID] = Accessor();
+    Accessor& acc = mAccessorLibrary[pID];
+    acc.mCount = count;
+    acc.mOffset = offset;
+    acc.mStride = stride;
+    acc.mSource = source+1; // ignore the leading '#'
+    acc.mSize = 0; // gets incremented with every param
+
+    // and read the components
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "param"))
+            {
+                // read data param
+                int attrName = TestAttribute( "name");
+                std::string name;
+                if( attrName > -1)
+                {
+                    name = mReader->getAttributeValue( attrName);
+
+                    // analyse for common type components and store it's sub-offset in the corresponding field
+
+                    /* Cartesian coordinates */
+                    if( name == "X") acc.mSubOffset[0] = acc.mParams.size();
+                    else if( name == "Y") acc.mSubOffset[1] = acc.mParams.size();
+                    else if( name == "Z") acc.mSubOffset[2] = acc.mParams.size();
+
+                    /* RGBA colors */
+                    else if( name == "R") acc.mSubOffset[0] = acc.mParams.size();
+                    else if( name == "G") acc.mSubOffset[1] = acc.mParams.size();
+                    else if( name == "B") acc.mSubOffset[2] = acc.mParams.size();
+                    else if( name == "A") acc.mSubOffset[3] = acc.mParams.size();
+
+                    /* UVWQ (STPQ) texture coordinates */
+                    else if( name == "S") acc.mSubOffset[0] = acc.mParams.size();
+                    else if( name == "T") acc.mSubOffset[1] = acc.mParams.size();
+                    else if( name == "P") acc.mSubOffset[2] = acc.mParams.size();
+                //  else if( name == "Q") acc.mSubOffset[3] = acc.mParams.size();
+                    /* 4D uv coordinates are not supported in Assimp */
+
+                    /* Generic extra data, interpreted as UV data, too*/
+                    else if( name == "U") acc.mSubOffset[0] = acc.mParams.size();
+                    else if( name == "V") acc.mSubOffset[1] = acc.mParams.size();
+                    //else
+                    //  DefaultLogger::get()->warn( boost::str( boost::format( "Unknown accessor parameter \"%s\". Ignoring data channel.") % name));
+                }
+
+                // read data type
+                int attrType = TestAttribute( "type");
+                if( attrType > -1)
+                {
+                    // for the moment we only distinguish between a 4x4 matrix and anything else.
+                    // TODO: (thom) I don't have a spec here at work. Check if there are other multi-value types
+                    // which should be tested for here.
+                    std::string type = mReader->getAttributeValue( attrType);
+                    if( type == "float4x4")
+                        acc.mSize += 16;
+                    else
+                        acc.mSize += 1;
+                }
+
+                acc.mParams.push_back( name);
+
+                // skip remaining stuff of this element, if any
+                SkipElement();
+            } else
+            {
+                ThrowException( boost::str( boost::format( "Unexpected sub element <%s> in tag <accessor>") % mReader->getNodeName()));
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "accessor") != 0)
+                ThrowException( "Expected end of <accessor> element.");
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads input declarations of per-vertex mesh data into the given mesh
+void ColladaParser::ReadVertexData( Mesh* pMesh)
+{
+    // extract the ID of the <vertices> element. Not that we care, but to catch strange referencing schemes we should warn about
+    int attrID= GetAttribute( "id");
+    pMesh->mVertexID = mReader->getAttributeValue( attrID);
+
+    // a number of <input> elements
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "input"))
+            {
+                ReadInputChannel( pMesh->mPerVertexData);
+            } else
+            {
+                ThrowException( boost::str( boost::format( "Unexpected sub element <%s> in tag <vertices>") % mReader->getNodeName()));
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "vertices") != 0)
+                ThrowException( "Expected end of <vertices> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads input declarations of per-index mesh data into the given mesh
+void ColladaParser::ReadIndexData( Mesh* pMesh)
+{
+    std::vector<size_t> vcount;
+    std::vector<InputChannel> perIndexData;
+
+    // read primitive count from the attribute
+    int attrCount = GetAttribute( "count");
+    size_t numPrimitives = (size_t) mReader->getAttributeValueAsInt( attrCount);
+    // some mesh types (e.g. tristrips) don't specify primitive count upfront,
+    // so we need to sum up the actual number of primitives while we read the <p>-tags
+    size_t actualPrimitives = 0;
+
+    // material subgroup
+    int attrMaterial = TestAttribute( "material");
+    SubMesh subgroup;
+    if( attrMaterial > -1)
+        subgroup.mMaterial = mReader->getAttributeValue( attrMaterial);
+
+    // distinguish between polys and triangles
+    std::string elementName = mReader->getNodeName();
+    PrimitiveType primType = Prim_Invalid;
+    if( IsElement( "lines"))
+        primType = Prim_Lines;
+    else if( IsElement( "linestrips"))
+        primType = Prim_LineStrip;
+    else if( IsElement( "polygons"))
+        primType = Prim_Polygon;
+    else if( IsElement( "polylist"))
+        primType = Prim_Polylist;
+    else if( IsElement( "triangles"))
+        primType = Prim_Triangles;
+    else if( IsElement( "trifans"))
+        primType = Prim_TriFans;
+    else if( IsElement( "tristrips"))
+        primType = Prim_TriStrips;
+
+    ai_assert( primType != Prim_Invalid);
+
+    // also a number of <input> elements, but in addition a <p> primitive collection and propably index counts for all primitives
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "input"))
+            {
+                ReadInputChannel( perIndexData);
+            }
+            else if( IsElement( "vcount"))
+            {
+                if( !mReader->isEmptyElement())
+                {
+                    if (numPrimitives)  // It is possible to define a mesh without any primitives
+                    {
+                        // case <polylist> - specifies the number of indices for each polygon
+                        const char* content = GetTextContent();
+                        vcount.reserve( numPrimitives);
+                        for( unsigned int a = 0; a < numPrimitives; a++)
+                        {
+                            if( *content == 0)
+                                ThrowException( "Expected more values while reading <vcount> contents.");
+                            // read a number
+                            vcount.push_back( (size_t) strtoul10( content, &content));
+                            // skip whitespace after it
+                            SkipSpacesAndLineEnd( &content);
+                        }
+                    }
+
+                    TestClosing( "vcount");
+                }
+            }
+            else if( IsElement( "p"))
+            {
+                if( !mReader->isEmptyElement())
+                {
+                    // now here the actual fun starts - these are the indices to construct the mesh data from
+                    actualPrimitives += ReadPrimitives(pMesh, perIndexData, numPrimitives, vcount, primType);
+                }
+            }
+            else if (IsElement("extra"))
+            {
+                SkipElement("extra");
+            } else
+            {
+                ThrowException( boost::str( boost::format( "Unexpected sub element <%s> in tag <%s>") % mReader->getNodeName() % elementName));
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( mReader->getNodeName() != elementName)
+                ThrowException( boost::str( boost::format( "Expected end of <%s> element.") % elementName));
+
+            break;
+        }
+    }
+
+#ifdef ASSIMP_BUILD_DEBUG
+    if (primType != Prim_TriFans && primType != Prim_TriStrips) {
+        ai_assert(actualPrimitives == numPrimitives);
+    }
+#endif
+
+    // only when we're done reading all <p> tags (and thus know the final vertex count) can we commit the submesh
+    subgroup.mNumFaces = actualPrimitives;
+    pMesh->mSubMeshes.push_back(subgroup);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a single input channel element and stores it in the given array, if valid
+void ColladaParser::ReadInputChannel( std::vector<InputChannel>& poChannels)
+{
+    InputChannel channel;
+
+    // read semantic
+    int attrSemantic = GetAttribute( "semantic");
+    std::string semantic = mReader->getAttributeValue( attrSemantic);
+    channel.mType = GetTypeForSemantic( semantic);
+
+    // read source
+    int attrSource = GetAttribute( "source");
+    const char* source = mReader->getAttributeValue( attrSource);
+    if( source[0] != '#')
+        ThrowException( boost::str( boost::format( "Unknown reference format in url \"%s\" in source attribute of <input> element.") % source));
+    channel.mAccessor = source+1; // skipping the leading #, hopefully the remaining text is the accessor ID only
+
+    // read index offset, if per-index <input>
+    int attrOffset = TestAttribute( "offset");
+    if( attrOffset > -1)
+        channel.mOffset = mReader->getAttributeValueAsInt( attrOffset);
+
+    // read set if texture coordinates
+    if(channel.mType == IT_Texcoord || channel.mType == IT_Color){
+        int attrSet = TestAttribute("set");
+        if(attrSet > -1){
+            attrSet = mReader->getAttributeValueAsInt( attrSet);
+            if(attrSet < 0)
+                ThrowException( boost::str( boost::format( "Invalid index \"%i\" in set attribute of <input> element") % (attrSet)));
+
+            channel.mIndex = attrSet;
+        }
+    }
+
+    // store, if valid type
+    if( channel.mType != IT_Invalid)
+        poChannels.push_back( channel);
+
+    // skip remaining stuff of this element, if any
+    SkipElement();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a <p> primitive index list and assembles the mesh data into the given mesh
+size_t ColladaParser::ReadPrimitives( Mesh* pMesh, std::vector<InputChannel>& pPerIndexChannels,
+    size_t pNumPrimitives, const std::vector<size_t>& pVCount, PrimitiveType pPrimType)
+{
+    // determine number of indices coming per vertex
+    // find the offset index for all per-vertex channels
+    size_t numOffsets = 1;
+    size_t perVertexOffset = SIZE_MAX; // invalid value
+    BOOST_FOREACH( const InputChannel& channel, pPerIndexChannels)
+    {
+        numOffsets = std::max( numOffsets, channel.mOffset+1);
+        if( channel.mType == IT_Vertex)
+            perVertexOffset = channel.mOffset;
+    }
+
+    // determine the expected number of indices
+    size_t expectedPointCount = 0;
+    switch( pPrimType)
+    {
+        case Prim_Polylist:
+        {
+            BOOST_FOREACH( size_t i, pVCount)
+                expectedPointCount += i;
+            break;
+        }
+        case Prim_Lines:
+            expectedPointCount = 2 * pNumPrimitives;
+            break;
+        case Prim_Triangles:
+            expectedPointCount = 3 * pNumPrimitives;
+            break;
+        default:
+            // other primitive types don't state the index count upfront... we need to guess
+            break;
+    }
+
+    // and read all indices into a temporary array
+    std::vector<size_t> indices;
+    if( expectedPointCount > 0)
+        indices.reserve( expectedPointCount * numOffsets);
+
+    if (pNumPrimitives > 0) // It is possible to not contain any indicies
+    {
+        const char* content = GetTextContent();
+        while( *content != 0)
+        {
+            // read a value.
+            // Hack: (thom) Some exporters put negative indices sometimes. We just try to carry on anyways.
+            int value = std::max( 0, strtol10( content, &content));
+            indices.push_back( size_t( value));
+            // skip whitespace after it
+            SkipSpacesAndLineEnd( &content);
+        }
+    }
+
+    // complain if the index count doesn't fit
+    if( expectedPointCount > 0 && indices.size() != expectedPointCount * numOffsets)
+        ThrowException( "Expected different index count in <p> element.");
+    else if( expectedPointCount == 0 && (indices.size() % numOffsets) != 0)
+        ThrowException( "Expected different index count in <p> element.");
+
+    // find the data for all sources
+  for( std::vector<InputChannel>::iterator it = pMesh->mPerVertexData.begin(); it != pMesh->mPerVertexData.end(); ++it)
+    {
+    InputChannel& input = *it;
+        if( input.mResolved)
+            continue;
+
+        // find accessor
+        input.mResolved = &ResolveLibraryReference( mAccessorLibrary, input.mAccessor);
+        // resolve accessor's data pointer as well, if neccessary
+        const Accessor* acc = input.mResolved;
+        if( !acc->mData)
+            acc->mData = &ResolveLibraryReference( mDataLibrary, acc->mSource);
+    }
+    // and the same for the per-index channels
+  for( std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it)
+  {
+    InputChannel& input = *it;
+        if( input.mResolved)
+            continue;
+
+        // ignore vertex pointer, it doesn't refer to an accessor
+        if( input.mType == IT_Vertex)
+        {
+            // warn if the vertex channel does not refer to the <vertices> element in the same mesh
+            if( input.mAccessor != pMesh->mVertexID)
+                ThrowException( "Unsupported vertex referencing scheme.");
+            continue;
+        }
+
+        // find accessor
+        input.mResolved = &ResolveLibraryReference( mAccessorLibrary, input.mAccessor);
+        // resolve accessor's data pointer as well, if neccessary
+        const Accessor* acc = input.mResolved;
+        if( !acc->mData)
+            acc->mData = &ResolveLibraryReference( mDataLibrary, acc->mSource);
+    }
+
+    // For continued primitives, the given count does not come all in one <p>, but only one primitive per <p>
+    size_t numPrimitives = pNumPrimitives;
+    if( pPrimType == Prim_TriFans || pPrimType == Prim_Polygon)
+        numPrimitives = 1;
+    // For continued primitives, the given count is actually the number of <p>'s inside the parent tag
+    if ( pPrimType == Prim_TriStrips){
+        size_t numberOfVertices = indices.size() / numOffsets;
+        numPrimitives = numberOfVertices - 2;
+    }
+
+    pMesh->mFaceSize.reserve( numPrimitives);
+    pMesh->mFacePosIndices.reserve( indices.size() / numOffsets);
+
+    size_t polylistStartVertex = 0;
+    for (size_t currentPrimitive = 0; currentPrimitive < numPrimitives; currentPrimitive++)
+    {
+        // determine number of points for this primitive
+        size_t numPoints = 0;
+        switch( pPrimType)
+        {
+            case Prim_Lines:
+                numPoints = 2;
+                for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+                    CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+                break;
+            case Prim_Triangles:
+                numPoints = 3;
+                for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+                    CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+                break;
+            case Prim_TriStrips:
+                numPoints = 3;
+                ReadPrimTriStrips(numOffsets, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+                break;
+            case Prim_Polylist:
+                numPoints = pVCount[currentPrimitive];
+                for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+                    CopyVertex(polylistStartVertex + currentVertex, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, 0, indices);
+                polylistStartVertex += numPoints;
+                break;
+            case Prim_TriFans:
+            case Prim_Polygon:
+                numPoints = indices.size() / numOffsets;
+                for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+                    CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+                break;
+            default:
+                // LineStrip is not supported due to expected index unmangling
+                ThrowException( "Unsupported primitive type.");
+                break;
+        }
+
+        // store the face size to later reconstruct the face from
+        pMesh->mFaceSize.push_back( numPoints);
+    }
+
+    // if I ever get my hands on that guy who invented this steaming pile of indirection...
+    TestClosing( "p");
+    return numPrimitives;
+}
+
+void ColladaParser::CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset, Mesh* pMesh, std::vector<InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices){
+    // calculate the base offset of the vertex whose attributes we ant to copy
+    size_t baseOffset = currentPrimitive * numOffsets * numPoints + currentVertex * numOffsets;
+
+    // don't overrun the boundaries of the index list
+    size_t maxIndexRequested = baseOffset + numOffsets - 1;
+    ai_assert(maxIndexRequested < indices.size());
+
+    // extract per-vertex channels using the global per-vertex offset
+    for (std::vector<InputChannel>::iterator it = pMesh->mPerVertexData.begin(); it != pMesh->mPerVertexData.end(); ++it)
+        ExtractDataObjectFromChannel(*it, indices[baseOffset + perVertexOffset], pMesh);
+    // and extract per-index channels using there specified offset
+    for (std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it)
+        ExtractDataObjectFromChannel(*it, indices[baseOffset + it->mOffset], pMesh);
+
+    // store the vertex-data index for later assignment of bone vertex weights
+    pMesh->mFacePosIndices.push_back(indices[baseOffset + perVertexOffset]);
+}
+
+void ColladaParser::ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Mesh* pMesh, std::vector<InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices){
+    if (currentPrimitive % 2 != 0){
+        //odd tristrip triangles need their indices mangled, to preserve winding direction
+        CopyVertex(1, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+        CopyVertex(0, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+        CopyVertex(2, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+    }
+    else {//for non tristrips or even tristrip triangles
+        CopyVertex(0, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+        CopyVertex(1, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+        CopyVertex(2, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Extracts a single object from an input channel and stores it in the appropriate mesh data array
+void ColladaParser::ExtractDataObjectFromChannel( const InputChannel& pInput, size_t pLocalIndex, Mesh* pMesh)
+{
+    // ignore vertex referrer - we handle them that separate
+    if( pInput.mType == IT_Vertex)
+        return;
+
+    const Accessor& acc = *pInput.mResolved;
+    if( pLocalIndex >= acc.mCount)
+        ThrowException( boost::str( boost::format( "Invalid data index (%d/%d) in primitive specification") % pLocalIndex % acc.mCount));
+
+    // get a pointer to the start of the data object referred to by the accessor and the local index
+    const float* dataObject = &(acc.mData->mValues[0]) + acc.mOffset + pLocalIndex* acc.mStride;
+
+    // assemble according to the accessors component sub-offset list. We don't care, yet,
+    // what kind of object exactly we're extracting here
+    float obj[4];
+    for( size_t c = 0; c < 4; ++c)
+        obj[c] = dataObject[acc.mSubOffset[c]];
+
+    // now we reinterpret it according to the type we're reading here
+    switch( pInput.mType)
+    {
+        case IT_Position: // ignore all position streams except 0 - there can be only one position
+            if( pInput.mIndex == 0)
+                pMesh->mPositions.push_back( aiVector3D( obj[0], obj[1], obj[2]));
+            else
+                DefaultLogger::get()->error("Collada: just one vertex position stream supported");
+            break;
+        case IT_Normal:
+            // pad to current vertex count if necessary
+            if( pMesh->mNormals.size() < pMesh->mPositions.size()-1)
+                pMesh->mNormals.insert( pMesh->mNormals.end(), pMesh->mPositions.size() - pMesh->mNormals.size() - 1, aiVector3D( 0, 1, 0));
+
+            // ignore all normal streams except 0 - there can be only one normal
+            if( pInput.mIndex == 0)
+                pMesh->mNormals.push_back( aiVector3D( obj[0], obj[1], obj[2]));
+            else
+                DefaultLogger::get()->error("Collada: just one vertex normal stream supported");
+            break;
+        case IT_Tangent:
+            // pad to current vertex count if necessary
+            if( pMesh->mTangents.size() < pMesh->mPositions.size()-1)
+                pMesh->mTangents.insert( pMesh->mTangents.end(), pMesh->mPositions.size() - pMesh->mTangents.size() - 1, aiVector3D( 1, 0, 0));
+
+            // ignore all tangent streams except 0 - there can be only one tangent
+            if( pInput.mIndex == 0)
+                pMesh->mTangents.push_back( aiVector3D( obj[0], obj[1], obj[2]));
+            else
+                DefaultLogger::get()->error("Collada: just one vertex tangent stream supported");
+            break;
+        case IT_Bitangent:
+            // pad to current vertex count if necessary
+            if( pMesh->mBitangents.size() < pMesh->mPositions.size()-1)
+                pMesh->mBitangents.insert( pMesh->mBitangents.end(), pMesh->mPositions.size() - pMesh->mBitangents.size() - 1, aiVector3D( 0, 0, 1));
+
+            // ignore all bitangent streams except 0 - there can be only one bitangent
+            if( pInput.mIndex == 0)
+                pMesh->mBitangents.push_back( aiVector3D( obj[0], obj[1], obj[2]));
+            else
+                DefaultLogger::get()->error("Collada: just one vertex bitangent stream supported");
+            break;
+        case IT_Texcoord:
+            // up to 4 texture coord sets are fine, ignore the others
+            if( pInput.mIndex < AI_MAX_NUMBER_OF_TEXTURECOORDS)
+            {
+                // pad to current vertex count if necessary
+                if( pMesh->mTexCoords[pInput.mIndex].size() < pMesh->mPositions.size()-1)
+                    pMesh->mTexCoords[pInput.mIndex].insert( pMesh->mTexCoords[pInput.mIndex].end(),
+                        pMesh->mPositions.size() - pMesh->mTexCoords[pInput.mIndex].size() - 1, aiVector3D( 0, 0, 0));
+
+                pMesh->mTexCoords[pInput.mIndex].push_back( aiVector3D( obj[0], obj[1], obj[2]));
+                if (0 != acc.mSubOffset[2] || 0 != acc.mSubOffset[3]) /* hack ... consider cleaner solution */
+                    pMesh->mNumUVComponents[pInput.mIndex]=3;
+            }   else
+            {
+                DefaultLogger::get()->error("Collada: too many texture coordinate sets. Skipping.");
+            }
+            break;
+        case IT_Color:
+            // up to 4 color sets are fine, ignore the others
+            if( pInput.mIndex < AI_MAX_NUMBER_OF_COLOR_SETS)
+            {
+                // pad to current vertex count if necessary
+                if( pMesh->mColors[pInput.mIndex].size() < pMesh->mPositions.size()-1)
+                    pMesh->mColors[pInput.mIndex].insert( pMesh->mColors[pInput.mIndex].end(),
+                        pMesh->mPositions.size() - pMesh->mColors[pInput.mIndex].size() - 1, aiColor4D( 0, 0, 0, 1));
+
+                aiColor4D result(0, 0, 0, 1);
+                for (size_t i = 0; i < pInput.mResolved->mSize; ++i)
+                {
+                    result[i] = obj[pInput.mResolved->mSubOffset[i]];
+                }
+                pMesh->mColors[pInput.mIndex].push_back(result);
+            } else
+            {
+                DefaultLogger::get()->error("Collada: too many vertex color sets. Skipping.");
+            }
+
+            break;
+        default:
+            // IT_Invalid and IT_Vertex
+            ai_assert(false && "shouldn't ever get here");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the library of node hierarchies and scene parts
+void ColladaParser::ReadSceneLibrary()
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            // a visual scene - generate root node under its ID and let ReadNode() do the recursive work
+            if( IsElement( "visual_scene"))
+            {
+                // read ID. Is optional according to the spec, but how on earth should a scene_instance refer to it then?
+                int indexID = GetAttribute( "id");
+                const char* attrID = mReader->getAttributeValue( indexID);
+
+                // read name if given.
+                int indexName = TestAttribute( "name");
+                const char* attrName = "unnamed";
+                if( indexName > -1)
+                    attrName = mReader->getAttributeValue( indexName);
+
+                // create a node and store it in the library under its ID
+                Node* node = new Node;
+                node->mID = attrID;
+                node->mName = attrName;
+                mNodeLibrary[node->mID] = node;
+
+                ReadSceneNode( node);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "library_visual_scenes") == 0)
+                //ThrowException( "Expected end of \"library_visual_scenes\" element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a scene node's contents including children and stores it in the given node
+void ColladaParser::ReadSceneNode( Node* pNode)
+{
+    // quit immediately on <bla/> elements
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "node"))
+            {
+                Node* child = new Node;
+                int attrID = TestAttribute( "id");
+                if( attrID > -1)
+                    child->mID = mReader->getAttributeValue( attrID);
+                int attrSID = TestAttribute( "sid");
+                if( attrSID > -1)
+                    child->mSID = mReader->getAttributeValue( attrSID);
+
+                int attrName = TestAttribute( "name");
+                if( attrName > -1)
+                    child->mName = mReader->getAttributeValue( attrName);
+
+                // TODO: (thom) support SIDs
+                // ai_assert( TestAttribute( "sid") == -1);
+
+                if (pNode)
+                {
+                    pNode->mChildren.push_back( child);
+                    child->mParent = pNode;
+                }
+                else
+                {
+                    // no parent node given, probably called from <library_nodes> element.
+                    // create new node in node library
+                    mNodeLibrary[child->mID] = child;
+                }
+
+                // read on recursively from there
+                ReadSceneNode( child);
+                continue;
+            }
+            // For any further stuff we need a valid node to work on
+            else if (!pNode)
+                continue;
+
+            if( IsElement( "lookat"))
+                ReadNodeTransformation( pNode, TF_LOOKAT);
+            else if( IsElement( "matrix"))
+                ReadNodeTransformation( pNode, TF_MATRIX);
+            else if( IsElement( "rotate"))
+                ReadNodeTransformation( pNode, TF_ROTATE);
+            else if( IsElement( "scale"))
+                ReadNodeTransformation( pNode, TF_SCALE);
+            else if( IsElement( "skew"))
+                ReadNodeTransformation( pNode, TF_SKEW);
+            else if( IsElement( "translate"))
+                ReadNodeTransformation( pNode, TF_TRANSLATE);
+            else if( IsElement( "render") && pNode->mParent == NULL && 0 == pNode->mPrimaryCamera.length())
+            {
+                // ... scene evaluation or, in other words, postprocessing pipeline,
+                // or, again in other words, a turing-complete description how to
+                // render a Collada scene. The only thing that is interesting for
+                // us is the primary camera.
+                int attrId = TestAttribute("camera_node");
+                if (-1 != attrId)
+                {
+                    const char* s = mReader->getAttributeValue(attrId);
+                    if (s[0] != '#')
+                        DefaultLogger::get()->error("Collada: Unresolved reference format of camera");
+                    else
+                        pNode->mPrimaryCamera = s+1;
+                }
+            }
+            else if( IsElement( "instance_node"))
+            {
+                // find the node in the library
+                int attrID = TestAttribute( "url");
+                if( attrID != -1)
+                {
+                    const char* s = mReader->getAttributeValue(attrID);
+                    if (s[0] != '#')
+                        DefaultLogger::get()->error("Collada: Unresolved reference format of node");
+                    else
+                    {
+                        pNode->mNodeInstances.push_back(NodeInstance());
+                        pNode->mNodeInstances.back().mNode = s+1;
+                    }
+                }
+            }
+            else if( IsElement( "instance_geometry") || IsElement( "instance_controller"))
+            {
+                // Reference to a mesh or controller, with possible material associations
+                ReadNodeGeometry( pNode);
+            }
+            else if( IsElement( "instance_light"))
+            {
+                // Reference to a light, name given in 'url' attribute
+                int attrID = TestAttribute("url");
+                if (-1 == attrID)
+                    DefaultLogger::get()->warn("Collada: Expected url attribute in <instance_light> element");
+                else
+                {
+                    const char* url = mReader->getAttributeValue( attrID);
+                    if( url[0] != '#')
+                        ThrowException( "Unknown reference format in <instance_light> element");
+
+                    pNode->mLights.push_back(LightInstance());
+                    pNode->mLights.back().mLight = url+1;
+                }
+            }
+            else if( IsElement( "instance_camera"))
+            {
+                // Reference to a camera, name given in 'url' attribute
+                int attrID = TestAttribute("url");
+                if (-1 == attrID)
+                    DefaultLogger::get()->warn("Collada: Expected url attribute in <instance_camera> element");
+                else
+                {
+                    const char* url = mReader->getAttributeValue( attrID);
+                    if( url[0] != '#')
+                        ThrowException( "Unknown reference format in <instance_camera> element");
+
+                    pNode->mCameras.push_back(CameraInstance());
+                    pNode->mCameras.back().mCamera = url+1;
+                }
+            }
+            else
+            {
+                // skip everything else for the moment
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a node transformation entry of the given type and adds it to the given node's transformation list.
+void ColladaParser::ReadNodeTransformation( Node* pNode, TransformType pType)
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    std::string tagName = mReader->getNodeName();
+
+    Transform tf;
+    tf.mType = pType;
+
+    // read SID
+    int indexSID = TestAttribute( "sid");
+    if( indexSID >= 0)
+        tf.mID = mReader->getAttributeValue( indexSID);
+
+    // how many parameters to read per transformation type
+    static const unsigned int sNumParameters[] = { 9, 4, 3, 3, 7, 16 };
+    const char* content = GetTextContent();
+
+    // read as many parameters and store in the transformation
+    for( unsigned int a = 0; a < sNumParameters[pType]; a++)
+    {
+        // read a number
+        content = fast_atoreal_move<float>( content, tf.f[a]);
+        // skip whitespace after it
+        SkipSpacesAndLineEnd( &content);
+    }
+
+    // place the transformation at the queue of the node
+    pNode->mTransforms.push_back( tf);
+
+    // and consume the closing tag
+    TestClosing( tagName.c_str());
+}
+
+// ------------------------------------------------------------------------------------------------
+// Processes bind_vertex_input and bind elements
+void ColladaParser::ReadMaterialVertexInputBinding( Collada::SemanticMappingTable& tbl)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if( IsElement( "bind_vertex_input"))
+            {
+                Collada::InputSemanticMapEntry vn;
+
+                // effect semantic
+                int n = GetAttribute("semantic");
+                std::string s = mReader->getAttributeValue(n);
+
+                // input semantic
+                n = GetAttribute("input_semantic");
+                vn.mType = GetTypeForSemantic( mReader->getAttributeValue(n) );
+
+                // index of input set
+                n = TestAttribute("input_set");
+                if (-1 != n)
+                    vn.mSet = mReader->getAttributeValueAsInt(n);
+
+                tbl.mMap[s] = vn;
+            }
+            else if( IsElement( "bind")) {
+                DefaultLogger::get()->warn("Collada: Found unsupported <bind> element");
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)    {
+            if( strcmp( mReader->getNodeName(), "instance_material") == 0)
+                break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a mesh reference in a node and adds it to the node's mesh list
+void ColladaParser::ReadNodeGeometry( Node* pNode)
+{
+    // referred mesh is given as an attribute of the <instance_geometry> element
+    int attrUrl = GetAttribute( "url");
+    const char* url = mReader->getAttributeValue( attrUrl);
+    if( url[0] != '#')
+        ThrowException( "Unknown reference format");
+
+    Collada::MeshInstance instance;
+    instance.mMeshOrController = url+1; // skipping the leading #
+
+    if( !mReader->isEmptyElement())
+    {
+        // read material associations. Ignore additional elements inbetween
+        while( mReader->read())
+        {
+            if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+            {
+                if( IsElement( "instance_material"))
+                {
+                    // read ID of the geometry subgroup and the target material
+                    int attrGroup = GetAttribute( "symbol");
+                    std::string group = mReader->getAttributeValue( attrGroup);
+                    int attrMaterial = GetAttribute( "target");
+                    const char* urlMat = mReader->getAttributeValue( attrMaterial);
+                    Collada::SemanticMappingTable s;
+                    if( urlMat[0] == '#')
+                        urlMat++;
+
+                    s.mMatName = urlMat;
+
+                    // resolve further material details + THIS UGLY AND NASTY semantic mapping stuff
+                    if( !mReader->isEmptyElement())
+                        ReadMaterialVertexInputBinding(s);
+
+                    // store the association
+                    instance.mMaterials[group] = s;
+                }
+            }
+            else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+            {
+                if( strcmp( mReader->getNodeName(), "instance_geometry") == 0
+                    || strcmp( mReader->getNodeName(), "instance_controller") == 0)
+                    break;
+            }
+        }
+    }
+
+    // store it
+    pNode->mMeshes.push_back( instance);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the collada scene
+void ColladaParser::ReadScene()
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if( IsElement( "instance_visual_scene"))
+            {
+                // should be the first and only occurence
+                if( mRootNode)
+                    ThrowException( "Invalid scene containing multiple root nodes in <instance_visual_scene> element");
+
+                // read the url of the scene to instance. Should be of format "#some_name"
+                int urlIndex = GetAttribute( "url");
+                const char* url = mReader->getAttributeValue( urlIndex);
+                if( url[0] != '#')
+                    ThrowException( "Unknown reference format in <instance_visual_scene> element");
+
+                // find the referred scene, skip the leading #
+                NodeLibrary::const_iterator sit = mNodeLibrary.find( url+1);
+                if( sit == mNodeLibrary.end())
+                    ThrowException( "Unable to resolve visual_scene reference \"" + std::string(url) + "\" in <instance_visual_scene> element.");
+                mRootNode = sit->second;
+            } else  {
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END){
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Aborts the file reading with an exception
+AI_WONT_RETURN void ColladaParser::ThrowException( const std::string& pError) const
+{
+    throw DeadlyImportError( boost::str( boost::format( "Collada: %s - %s") % mFileName % pError));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Skips all data until the end node of the current element
+void ColladaParser::SkipElement()
+{
+    // nothing to skip if it's an <element />
+    if( mReader->isEmptyElement())
+        return;
+
+    // reroute
+    SkipElement( mReader->getNodeName());
+}
+
+// ------------------------------------------------------------------------------------------------
+// Skips all data until the end node of the given element
+void ColladaParser::SkipElement( const char* pElement)
+{
+    // copy the current node's name because it'a pointer to the reader's internal buffer,
+    // which is going to change with the upcoming parsing
+    std::string element = pElement;
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+            if( mReader->getNodeName() == element)
+                break;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Tests for an opening element of the given name, throws an exception if not found
+void ColladaParser::TestOpening( const char* pName)
+{
+    // read element start
+    if( !mReader->read())
+        ThrowException( boost::str( boost::format( "Unexpected end of file while beginning of <%s> element.") % pName));
+    // whitespace in front is ok, just read again if found
+    if( mReader->getNodeType() == irr::io::EXN_TEXT)
+        if( !mReader->read())
+            ThrowException( boost::str( boost::format( "Unexpected end of file while reading beginning of <%s> element.") % pName));
+
+    if( mReader->getNodeType() != irr::io::EXN_ELEMENT || strcmp( mReader->getNodeName(), pName) != 0)
+        ThrowException( boost::str( boost::format( "Expected start of <%s> element.") % pName));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Tests for the closing tag of the given element, throws an exception if not found
+void ColladaParser::TestClosing( const char* pName)
+{
+    // check if we're already on the closing tag and return right away
+    if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END && strcmp( mReader->getNodeName(), pName) == 0)
+        return;
+
+    // if not, read some more
+    if( !mReader->read())
+        ThrowException( boost::str( boost::format( "Unexpected end of file while reading end of <%s> element.") % pName));
+    // whitespace in front is ok, just read again if found
+    if( mReader->getNodeType() == irr::io::EXN_TEXT)
+        if( !mReader->read())
+            ThrowException( boost::str( boost::format( "Unexpected end of file while reading end of <%s> element.") % pName));
+
+    // but this has the be the closing tag, or we're lost
+    if( mReader->getNodeType() != irr::io::EXN_ELEMENT_END || strcmp( mReader->getNodeName(), pName) != 0)
+        ThrowException( boost::str( boost::format( "Expected end of <%s> element.") % pName));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns the index of the named attribute or -1 if not found. Does not throw, therefore useful for optional attributes
+int ColladaParser::GetAttribute( const char* pAttr) const
+{
+    int index = TestAttribute( pAttr);
+    if( index != -1)
+        return index;
+
+    // attribute not found -> throw an exception
+    ThrowException( boost::str( boost::format( "Expected attribute \"%s\" for element <%s>.") % pAttr % mReader->getNodeName()));
+    return -1;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Tests the present element for the presence of one attribute, returns its index or throws an exception if not found
+int ColladaParser::TestAttribute( const char* pAttr) const
+{
+    for( int a = 0; a < mReader->getAttributeCount(); a++)
+        if( strcmp( mReader->getAttributeName( a), pAttr) == 0)
+            return a;
+
+    return -1;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the text contents of an element, throws an exception if not given. Skips leading whitespace.
+const char* ColladaParser::GetTextContent()
+{
+    const char* sz = TestTextContent();
+    if(!sz) {
+        ThrowException( "Invalid contents in element \"n\".");
+    }
+    return sz;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the text contents of an element, returns NULL if not given. Skips leading whitespace.
+const char* ColladaParser::TestTextContent()
+{
+    // present node should be the beginning of an element
+    if( mReader->getNodeType() != irr::io::EXN_ELEMENT || mReader->isEmptyElement())
+        return NULL;
+
+    // read contents of the element
+    if( !mReader->read() )
+        return NULL;
+    if( mReader->getNodeType() != irr::io::EXN_TEXT)
+        return NULL;
+
+    // skip leading whitespace
+    const char* text = mReader->getNodeData();
+    SkipSpacesAndLineEnd( &text);
+
+    return text;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Calculates the resulting transformation fromm all the given transform steps
+aiMatrix4x4 ColladaParser::CalculateResultTransform( const std::vector<Transform>& pTransforms) const
+{
+    aiMatrix4x4 res;
+
+    for( std::vector<Transform>::const_iterator it = pTransforms.begin(); it != pTransforms.end(); ++it)
+    {
+        const Transform& tf = *it;
+        switch( tf.mType)
+        {
+            case TF_LOOKAT:
+      {
+        aiVector3D pos( tf.f[0], tf.f[1], tf.f[2]);
+        aiVector3D dstPos( tf.f[3], tf.f[4], tf.f[5]);
+        aiVector3D up = aiVector3D( tf.f[6], tf.f[7], tf.f[8]).Normalize();
+        aiVector3D dir = aiVector3D( dstPos - pos).Normalize();
+        aiVector3D right = (dir ^ up).Normalize();
+
+        res *= aiMatrix4x4(
+          right.x, up.x, -dir.x, pos.x,
+          right.y, up.y, -dir.y, pos.y,
+          right.z, up.z, -dir.z, pos.z,
+          0, 0, 0, 1);
+                break;
+      }
+            case TF_ROTATE:
+            {
+                aiMatrix4x4 rot;
+                float angle = tf.f[3] * float( AI_MATH_PI) / 180.0f;
+                aiVector3D axis( tf.f[0], tf.f[1], tf.f[2]);
+                aiMatrix4x4::Rotation( angle, axis, rot);
+                res *= rot;
+                break;
+            }
+            case TF_TRANSLATE:
+            {
+                aiMatrix4x4 trans;
+                aiMatrix4x4::Translation( aiVector3D( tf.f[0], tf.f[1], tf.f[2]), trans);
+                res *= trans;
+                break;
+            }
+            case TF_SCALE:
+            {
+                aiMatrix4x4 scale( tf.f[0], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[1], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[2], 0.0f,
+                    0.0f, 0.0f, 0.0f, 1.0f);
+                res *= scale;
+                break;
+            }
+            case TF_SKEW:
+                // TODO: (thom)
+                ai_assert( false);
+                break;
+            case TF_MATRIX:
+            {
+                aiMatrix4x4 mat( tf.f[0], tf.f[1], tf.f[2], tf.f[3], tf.f[4], tf.f[5], tf.f[6], tf.f[7],
+                    tf.f[8], tf.f[9], tf.f[10], tf.f[11], tf.f[12], tf.f[13], tf.f[14], tf.f[15]);
+                res *= mat;
+                break;
+            }
+            default:
+                ai_assert( false);
+                break;
+        }
+    }
+
+    return res;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Determines the input data type for the given semantic string
+Collada::InputType ColladaParser::GetTypeForSemantic( const std::string& pSemantic)
+{
+    if( pSemantic == "POSITION")
+        return IT_Position;
+    else if( pSemantic == "TEXCOORD")
+        return IT_Texcoord;
+    else if( pSemantic == "NORMAL")
+        return IT_Normal;
+    else if( pSemantic == "COLOR")
+        return IT_Color;
+    else if( pSemantic == "VERTEX")
+        return IT_Vertex;
+    else if( pSemantic == "BINORMAL" || pSemantic ==  "TEXBINORMAL")
+        return IT_Bitangent;
+    else if( pSemantic == "TANGENT" || pSemantic == "TEXTANGENT")
+        return IT_Tangent;
+
+    DefaultLogger::get()->warn( boost::str( boost::format( "Unknown vertex input type \"%s\". Ignoring.") % pSemantic));
+    return IT_Invalid;
+}
+
+#endif // !! ASSIMP_BUILD_NO_DAE_IMPORTER

code/ColladaParser upstream.h

@@ -0,0 +1,352 @@
+/*
+ Open Asset Import Library (assimp)
+ ----------------------------------------------------------------------
+ 
+ Copyright (c) 2006-2015, assimp team
+ All rights reserved.
+ 
+ Redistribution and use of this software in source and binary forms,
+ with or without modification, are permitted provided that the
+ following conditions are met:
+ 
+ * Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+ 
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+ 
+ * Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ ----------------------------------------------------------------------
+ */
+
+/** @file ColladaParser.h
+ *  @brief Defines the parser helper class for the collada loader
+ */
+
+#ifndef AI_COLLADAPARSER_H_INC
+#define AI_COLLADAPARSER_H_INC
+
+#include "irrXMLWrapper.h"
+#include "ColladaHelper.h"
+#include "../include/assimp/ai_assert.h"
+#include <boost/format.hpp>
+
+namespace Assimp
+{
+    
+    // ------------------------------------------------------------------------------------------
+    /** Parser helper class for the Collada loader.
+     *
+     *  Does all the XML reading and builds internal data structures from it,
+     *  but leaves the resolving of all the references to the loader.
+     */
+    class ColladaParser
+    {
+        friend class ColladaLoader;
+        
+    protected:
+        /** Constructor from XML file */
+        ColladaParser( IOSystem* pIOHandler, const std::string& pFile);
+        
+        /** Destructor */
+        ~ColladaParser();
+        
+        /** Reads the contents of the file */
+        void ReadContents();
+        
+        /** Reads the structure of the file */
+        void ReadStructure();
+        
+        /** Reads asset informations such as coordinate system informations and legal blah */
+        void ReadAssetInfo();
+        
+        /** Reads the animation library */
+        void ReadAnimationLibrary();
+        
+        /** Reads an animation into the given parent structure */
+        void ReadAnimation( Collada::Animation* pParent);
+        
+        /** Reads an animation sampler into the given anim channel */
+        void ReadAnimationSampler( Collada::AnimationChannel& pChannel);
+        
+        /** Reads the skeleton controller library */
+        void ReadControllerLibrary();
+        
+        /** Reads a controller into the given mesh structure */
+        void ReadController( Collada::Controller& pController);
+        
+        /** Reads the joint definitions for the given controller */
+        void ReadControllerJoints( Collada::Controller& pController);
+        
+        /** Reads the joint weights for the given controller */
+        void ReadControllerWeights( Collada::Controller& pController);
+        
+        /** Reads the image library contents */
+        void ReadImageLibrary();
+        
+        /** Reads an image entry into the given image */
+        void ReadImage( Collada::Image& pImage);
+        
+        /** Reads the material library */
+        void ReadMaterialLibrary();
+        
+        /** Reads a material entry into the given material */
+        void ReadMaterial( Collada::Material& pMaterial);
+        
+        /** Reads the camera library */
+        void ReadCameraLibrary();
+        
+        /** Reads a camera entry into the given camera */
+        void ReadCamera( Collada::Camera& pCamera);
+        
+        /** Reads the light library */
+        void ReadLightLibrary();
+        
+        /** Reads a light entry into the given light */
+        void ReadLight( Collada::Light& pLight);
+        
+        /** Reads the effect library */
+        void ReadEffectLibrary();
+        
+        /** Reads an effect entry into the given effect*/
+        void ReadEffect( Collada::Effect& pEffect);
+        
+        /** Reads an COMMON effect profile */
+        void ReadEffectProfileCommon( Collada::Effect& pEffect);
+        
+        /** Read sampler properties */
+        void ReadSamplerProperties( Collada::Sampler& pSampler);
+        
+        /** Reads an effect entry containing a color or a texture defining that color */
+        void ReadEffectColor( aiColor4D& pColor, Collada::Sampler& pSampler);
+        
+        /** Reads an effect entry containing a float */
+        void ReadEffectFloat( float& pFloat);
+        
+        /** Reads an effect parameter specification of any kind */
+        void ReadEffectParam( Collada::EffectParam& pParam);
+        
+        /** Reads the geometry library contents */
+        void ReadGeometryLibrary();
+        
+        /** Reads a geometry from the geometry library. */
+        void ReadGeometry( Collada::Mesh* pMesh);
+        
+        /** Reads a mesh from the geometry library */
+        void ReadMesh( Collada::Mesh* pMesh);
+        
+        /** Reads a source element - a combination of raw data and an accessor defining
+         * things that should not be redefinable. Yes, that's another rant.
+         */
+        void ReadSource();
+        
+        /** Reads a data array holding a number of elements, and stores it in the global library.
+         * Currently supported are array of floats and arrays of strings.
+         */
+        void ReadDataArray();
+        
+        /** Reads an accessor and stores it in the global library under the given ID -
+         * accessors use the ID of the parent <source> element
+         */
+        void ReadAccessor( const std::string& pID);
+        
+        /** Reads input declarations of per-vertex mesh data into the given mesh */
+        void ReadVertexData( Collada::Mesh* pMesh);
+        
+        /** Reads input declarations of per-index mesh data into the given mesh */
+        void ReadIndexData( Collada::Mesh* pMesh);
+        
+        /** Reads a single input channel element and stores it in the given array, if valid */
+        void ReadInputChannel( std::vector<Collada::InputChannel>& poChannels);
+        
+        /** Reads a <p> primitive index list and assembles the mesh data into the given mesh */
+        size_t ReadPrimitives( Collada::Mesh* pMesh, std::vector<Collada::InputChannel>& pPerIndexChannels,
+                              size_t pNumPrimitives, const std::vector<size_t>& pVCount, Collada::PrimitiveType pPrimType);
+        
+        /** Copies the data for a single primitive into the mesh, based on the InputChannels */
+        void CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset,
+                        Collada::Mesh* pMesh, std::vector<Collada::InputChannel>& pPerIndexChannels,
+                        size_t currentPrimitive, const std::vector<size_t>& indices);
+        
+        /** Reads one triangle of a tristrip into the mesh */
+        void ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Collada::Mesh* pMesh,
+                               std::vector<Collada::InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices);
+        
+        /** Extracts a single object from an input channel and stores it in the appropriate mesh data array */
+        void ExtractDataObjectFromChannel( const Collada::InputChannel& pInput, size_t pLocalIndex, Collada::Mesh* pMesh);
+        
+        /** Reads the library of node hierarchies and scene parts */
+        void ReadSceneLibrary();
+        
+        /** Reads a scene node's contents including children and stores it in the given node */
+        void ReadSceneNode( Collada::Node* pNode);
+        
+        /** Reads a node transformation entry of the given type and adds it to the given node's transformation list. */
+        void ReadNodeTransformation( Collada::Node* pNode, Collada::TransformType pType);
+        
+        /** Reads a mesh reference in a node and adds it to the node's mesh list */
+        void ReadNodeGeometry( Collada::Node* pNode);
+        
+        /** Reads the collada scene */
+        void ReadScene();
+        
+        // Processes bind_vertex_input and bind elements
+        void ReadMaterialVertexInputBinding( Collada::SemanticMappingTable& tbl);
+        
+    protected:
+        /** Aborts the file reading with an exception */
+        AI_WONT_RETURN void ThrowException( const std::string& pError) const AI_WONT_RETURN_SUFFIX;
+        
+        /** Skips all data until the end node of the current element */
+        void SkipElement();
+        
+        /** Skips all data until the end node of the given element */
+        void SkipElement( const char* pElement);
+        
+        /** Compares the current xml element name to the given string and returns true if equal */
+        bool IsElement( const char* pName) const;
+        
+        /** Tests for the opening tag of the given element, throws an exception if not found */
+        void TestOpening( const char* pName);
+        
+        /** Tests for the closing tag of the given element, throws an exception if not found */
+        void TestClosing( const char* pName);
+        
+        /** Checks the present element for the presence of the attribute, returns its index
+         or throws an exception if not found */
+        int GetAttribute( const char* pAttr) const;
+        
+        /** Returns the index of the named attribute or -1 if not found. Does not throw,
+         therefore useful for optional attributes */
+        int TestAttribute( const char* pAttr) const;
+        
+        /** Reads the text contents of an element, throws an exception if not given.
+         Skips leading whitespace. */
+        const char* GetTextContent();
+        
+        /** Reads the text contents of an element, returns NULL if not given.
+         Skips leading whitespace. */
+        const char* TestTextContent();
+        
+        /** Reads a single bool from current text content */
+        bool ReadBoolFromTextContent();
+        
+        /** Reads a single float from current text content */
+        float ReadFloatFromTextContent();
+        
+        /** Calculates the resulting transformation from all the given transform steps */
+        aiMatrix4x4 CalculateResultTransform( const std::vector<Collada::Transform>& pTransforms) const;
+        
+        /** Determines the input data type for the given semantic string */
+        Collada::InputType GetTypeForSemantic( const std::string& pSemantic);
+        
+        /** Finds the item in the given library by its reference, throws if not found */
+        template <typename Type> const Type& ResolveLibraryReference(
+                                                                     const std::map<std::string, Type>& pLibrary, const std::string& pURL) const;
+        
+    protected:
+        /** Filename, for a verbose error message */
+        std::string mFileName;
+        
+        /** XML reader, member for everyday use */
+        irr::io::IrrXMLReader* mReader;
+        
+        /** All data arrays found in the file by ID. Might be referred to by actually
+         everyone. Collada, you are a steaming pile of indirection. */
+        typedef std::map<std::string, Collada::Data> DataLibrary;
+        DataLibrary mDataLibrary;
+        
+        /** Same for accessors which define how the data in a data array is accessed. */
+        typedef std::map<std::string, Collada::Accessor> AccessorLibrary;
+        AccessorLibrary mAccessorLibrary;
+        
+        /** Mesh library: mesh by ID */
+        typedef std::map<std::string, Collada::Mesh*> MeshLibrary;
+        MeshLibrary mMeshLibrary;
+        
+        /** node library: root node of the hierarchy part by ID */
+        typedef std::map<std::string, Collada::Node*> NodeLibrary;
+        NodeLibrary mNodeLibrary;
+        
+        /** Image library: stores texture properties by ID */
+        typedef std::map<std::string, Collada::Image> ImageLibrary;
+        ImageLibrary mImageLibrary;
+        
+        /** Effect library: surface attributes by ID */
+        typedef std::map<std::string, Collada::Effect> EffectLibrary;
+        EffectLibrary mEffectLibrary;
+        
+        /** Material library: surface material by ID */
+        typedef std::map<std::string, Collada::Material> MaterialLibrary;
+        MaterialLibrary mMaterialLibrary;
+        
+        /** Light library: surface light by ID */
+        typedef std::map<std::string, Collada::Light> LightLibrary;
+        LightLibrary mLightLibrary;
+        
+        /** Camera library: surface material by ID */
+        typedef std::map<std::string, Collada::Camera> CameraLibrary;
+        CameraLibrary mCameraLibrary;
+        
+        /** Controller library: joint controllers by ID */
+        typedef std::map<std::string, Collada::Controller> ControllerLibrary;
+        ControllerLibrary mControllerLibrary;
+        
+        /** Pointer to the root node. Don't delete, it just points to one of
+         the nodes in the node library. */
+        Collada::Node* mRootNode;
+        
+        /** Root animation container */
+        Collada::Animation mAnims;
+        
+        /** Size unit: how large compared to a meter */
+        float mUnitSize;
+        
+        /** Which is the up vector */
+        enum { UP_X, UP_Y, UP_Z } mUpDirection;
+        
+        /** Collada file format version */
+        Collada::FormatVersion mFormat;
+    };
+    
+    // ------------------------------------------------------------------------------------------------
+    // Check for element match
+    inline bool ColladaParser::IsElement( const char* pName) const
+    {
+        ai_assert( mReader->getNodeType() == irr::io::EXN_ELEMENT);
+        return ::strcmp( mReader->getNodeName(), pName) == 0;
+    }
+    
+    // ------------------------------------------------------------------------------------------------
+    // Finds the item in the given library by its reference, throws if not found
+    template <typename Type>
+    const Type& ColladaParser::ResolveLibraryReference( const std::map<std::string, Type>& pLibrary, const std::string& pURL) const
+    {
+        typename std::map<std::string, Type>::const_iterator it = pLibrary.find( pURL);
+        if( it == pLibrary.end())
+            ThrowException( boost::str( boost::format( "Unable to resolve library reference \"%s\".") % pURL));
+        return it->second;
+    }
+    
+} // end of namespace Assimp
+
+#endif // AI_COLLADAPARSER_H_INC

code/ColladaParser wil.cpp

@@ -0,0 +1,2933 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, 
+with or without modification, are permitted provided that the following 
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file ColladaParser.cpp
+ *  @brief Implementation of the Collada parser helper
+ */
+
+#include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER
+
+#include "ColladaParser.h"
+#include "fast_atof.h"
+#include "ParsingUtils.h"
+
+using namespace Assimp;
+using namespace Assimp::Collada;
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+ColladaParser::ColladaParser( IOSystem* pIOHandler, const std::string& pFile)
+    : mFileName( pFile)
+{
+    mRootNode = NULL;
+    mUnitSize = 1.0f;
+    mUpDirection = UP_Y;
+
+    // We assume the newest file format by default
+    mFormat = FV_1_5_n;
+
+  // open the file
+  boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile));
+  if( file.get() == NULL)
+    throw DeadlyImportError( "Failed to open file " + pFile + ".");
+
+    // generate a XML reader for it
+  boost::scoped_ptr<CIrrXML_IOStreamReader> mIOWrapper( new CIrrXML_IOStreamReader( file.get()));
+    mReader = irr::io::createIrrXMLReader( mIOWrapper.get());
+    if( !mReader)
+        ThrowException( "Collada: Unable to open file.");
+
+    // start reading
+    ReadContents();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+ColladaParser::~ColladaParser()
+{
+    delete mReader;
+    for( NodeLibrary::iterator it = mNodeLibrary.begin(); it != mNodeLibrary.end(); ++it)
+        delete it->second;
+    for( MeshLibrary::iterator it = mMeshLibrary.begin(); it != mMeshLibrary.end(); ++it)
+        delete it->second;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Read bool from text contents of current element
+bool ColladaParser::ReadBoolFromTextContent()
+{
+    const char* cur = GetTextContent();
+    return (!ASSIMP_strincmp(cur,"true",4) || '0' != *cur);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Read float from text contents of current element
+float ColladaParser::ReadFloatFromTextContent()
+{
+    const char* cur = GetTextContent();
+    return fast_atof(cur);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the contents of the file
+void ColladaParser::ReadContents()
+{
+    while( mReader->read())
+    {
+        // handle the root element "COLLADA"
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "COLLADA"))
+            {
+                // check for 'version' attribute
+                const int attrib = TestAttribute("version");
+                if (attrib != -1) {
+                    const char* version = mReader->getAttributeValue(attrib);
+                    
+                    if (!::strncmp(version,"1.5",3)) {
+                        mFormat =  FV_1_5_n;
+                        DefaultLogger::get()->debug("Collada schema version is 1.5.n");
+                    }
+                    else if (!::strncmp(version,"1.4",3)) {
+                        mFormat =  FV_1_4_n;
+                        DefaultLogger::get()->debug("Collada schema version is 1.4.n");
+                    }
+                    else if (!::strncmp(version,"1.3",3)) {
+                        mFormat =  FV_1_3_n;
+                        DefaultLogger::get()->debug("Collada schema version is 1.3.n");
+                    }
+                }
+
+                ReadStructure();
+            } else
+            {
+                DefaultLogger::get()->debug( boost::str( boost::format( "Ignoring global element <%s>.") % mReader->getNodeName()));
+                SkipElement();
+            }
+        } else
+        {
+            // skip everything else silently
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the structure of the file
+void ColladaParser::ReadStructure()
+{
+    while( mReader->read())
+    {
+        // beginning of elements
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) 
+        {
+            if( IsElement( "asset"))
+                ReadAssetInfo();
+            else if( IsElement( "library_animations"))
+                ReadAnimationLibrary();
+            else if( IsElement( "library_controllers"))
+                ReadControllerLibrary();
+            else if( IsElement( "library_images"))
+                ReadImageLibrary();
+            else if( IsElement( "library_materials"))
+                ReadMaterialLibrary();
+            else if( IsElement( "library_effects"))
+                ReadEffectLibrary();
+            else if( IsElement( "library_geometries"))
+                ReadGeometryLibrary();
+            else if( IsElement( "library_visual_scenes"))
+                ReadSceneLibrary();
+            else if( IsElement( "library_lights"))
+                ReadLightLibrary();
+            else if( IsElement( "library_cameras"))
+                ReadCameraLibrary();
+            else if( IsElement( "library_nodes"))
+                ReadSceneNode(NULL); /* some hacking to reuse this piece of code */
+            else if( IsElement( "scene"))
+                ReadScene();
+            else
+                SkipElement();
+        } 
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) 
+        {
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads asset informations such as coordinate system informations and legal blah
+void ColladaParser::ReadAssetInfo()
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "unit"))
+            {
+                // read unit data from the element's attributes
+                const int attrIndex = TestAttribute( "meter");
+                if (attrIndex == -1) {
+                    mUnitSize = 1.f;
+                }
+                else {
+                    mUnitSize = mReader->getAttributeValueAsFloat( attrIndex);
+                }
+
+                // consume the trailing stuff
+                if( !mReader->isEmptyElement())
+                    SkipElement();
+            } 
+            else if( IsElement( "up_axis"))
+            {
+                // read content, strip whitespace, compare
+                const char* content = GetTextContent();
+                if( strncmp( content, "X_UP", 4) == 0)
+                    mUpDirection = UP_X;
+                else if( strncmp( content, "Z_UP", 4) == 0)
+                    mUpDirection = UP_Z;
+                else
+                    mUpDirection = UP_Y;
+
+                // check element end
+                TestClosing( "up_axis");
+            } else
+            {
+                SkipElement();
+            }
+        } 
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "asset") != 0)
+                ThrowException( "Expected end of <asset> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the animation library
+void ColladaParser::ReadAnimationLibrary()
+{
+    if (mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) 
+        {
+            if( IsElement( "animation"))
+            {
+                // delegate the reading. Depending on the inner elements it will be a container or a anim channel
+                ReadAnimation( &mAnims);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) 
+        {
+            if( strcmp( mReader->getNodeName(), "library_animations") != 0)
+                ThrowException( "Expected end of <library_animations> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an animation into the given parent structure
+void ColladaParser::ReadAnimation( Collada::Animation* pParent)
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    // an <animation> element may be a container for grouping sub-elements or an animation channel
+    // this is the channel collection by ID, in case it has channels
+    typedef std::map<std::string, AnimationChannel> ChannelMap;
+    ChannelMap channels;
+    // this is the anim container in case we're a container
+    Animation* anim = NULL;
+
+    // optional name given as an attribute
+    std::string animName;
+    int indexName = TestAttribute( "name");
+    int indexID = TestAttribute( "id");
+    if( indexName >= 0)
+        animName = mReader->getAttributeValue( indexName);
+    else if( indexID >= 0)
+        animName = mReader->getAttributeValue( indexID);
+    else
+        animName = "animation";
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) 
+        {
+            // we have subanimations
+            if( IsElement( "animation"))
+            {
+                // create container from our element
+                if( !anim)
+                {
+                    anim = new Animation;
+                    anim->mName = animName;
+                    pParent->mSubAnims.push_back( anim);
+                }
+
+                // recurse into the subelement
+                ReadAnimation( anim);
+            } 
+            else if( IsElement( "source"))
+            {
+                // possible animation data - we'll never know. Better store it
+                ReadSource();
+            } 
+            else if( IsElement( "sampler"))
+            {
+                // read the ID to assign the corresponding collada channel afterwards.
+                int indexID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( indexID);
+                ChannelMap::iterator newChannel = channels.insert( std::make_pair( id, AnimationChannel())).first;
+
+                // have it read into a channel
+                ReadAnimationSampler( newChannel->second);
+            } 
+            else if( IsElement( "channel"))
+            {
+                // the binding element whose whole purpose is to provide the target to animate
+                // Thanks, Collada! A directly posted information would have been too simple, I guess.
+                // Better add another indirection to that! Can't have enough of those.
+                int indexTarget = GetAttribute( "target");
+                int indexSource = GetAttribute( "source");
+                const char* sourceId = mReader->getAttributeValue( indexSource);
+                if( sourceId[0] == '#')
+                    sourceId++;
+                ChannelMap::iterator cit = channels.find( sourceId);
+                if( cit != channels.end())
+                    cit->second.mTarget = mReader->getAttributeValue( indexTarget);
+
+                if( !mReader->isEmptyElement())
+                    SkipElement();
+            } 
+            else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) 
+        {
+            if( strcmp( mReader->getNodeName(), "animation") != 0)
+                ThrowException( "Expected end of <animation> element.");
+
+            break;
+        }
+    }
+
+    // it turned out to have channels - add them
+    if( !channels.empty())
+    {
+        // special filtering for stupid exporters packing each channel into a separate animation
+        if( channels.size() == 1)
+        {
+            pParent->mChannels.push_back( channels.begin()->second);
+        } else
+        {
+            // else create the animation, if not done yet, and store the channels
+            if( !anim)
+            {
+                anim = new Animation;
+                anim->mName = animName;
+                pParent->mSubAnims.push_back( anim);
+            }
+            for( ChannelMap::const_iterator it = channels.begin(); it != channels.end(); ++it)
+                anim->mChannels.push_back( it->second);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an animation sampler into the given anim channel
+void ColladaParser::ReadAnimationSampler( Collada::AnimationChannel& pChannel)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) 
+        {
+            if( IsElement( "input"))
+            {
+                int indexSemantic = GetAttribute( "semantic");
+                const char* semantic = mReader->getAttributeValue( indexSemantic);
+                int indexSource = GetAttribute( "source");
+                const char* source = mReader->getAttributeValue( indexSource);
+                if( source[0] != '#')
+                    ThrowException( "Unsupported URL format");
+                source++;
+                
+                if( strcmp( semantic, "INPUT") == 0)
+                    pChannel.mSourceTimes = source;
+                else if( strcmp( semantic, "OUTPUT") == 0)
+                    pChannel.mSourceValues = source;
+
+                if( !mReader->isEmptyElement())
+                    SkipElement();
+            } 
+            else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) 
+        {
+            if( strcmp( mReader->getNodeName(), "sampler") != 0)
+                ThrowException( "Expected end of <sampler> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the skeleton controller library
+void ColladaParser::ReadControllerLibrary()
+{
+    if (mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) 
+        {
+            if( IsElement( "controller"))
+            {
+                // read ID. Ask the spec if it's neccessary or optional... you might be surprised.
+                int attrID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( attrID);
+
+                // create an entry and store it in the library under its ID
+                mControllerLibrary[id] = Controller();
+
+                // read on from there
+                ReadController( mControllerLibrary[id]);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) 
+        {
+            if( strcmp( mReader->getNodeName(), "library_controllers") != 0)
+                ThrowException( "Expected end of <library_controllers> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a controller into the given mesh structure
+void ColladaParser::ReadController( Collada::Controller& pController)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) 
+        {
+            // two types of controllers: "skin" and "morph". Only the first one is relevant, we skip the other
+            if( IsElement( "morph"))
+            {
+                // should skip everything inside, so there's no danger of catching elements inbetween
+                SkipElement();
+            } 
+            else if( IsElement( "skin"))
+            {
+                // read the mesh it refers to. According to the spec this could also be another
+                // controller, but I refuse to implement every single idea they've come up with
+                int sourceIndex = GetAttribute( "source");
+                pController.mMeshId = mReader->getAttributeValue( sourceIndex) + 1;
+            } 
+            else if( IsElement( "bind_shape_matrix"))
+            {
+                // content is 16 floats to define a matrix... it seems to be important for some models
+          const char* content = GetTextContent();
+
+          // read the 16 floats
+          for( unsigned int a = 0; a < 16; a++)
+          {
+              // read a number
+          content = fast_atoreal_move<float>( content, pController.mBindShapeMatrix[a]);
+              // skip whitespace after it
+              SkipSpacesAndLineEnd( &content);
+          }
+
+        TestClosing( "bind_shape_matrix");
+            } 
+            else if( IsElement( "source"))
+            {
+                // data array - we have specialists to handle this
+                ReadSource();
+            } 
+            else if( IsElement( "joints"))
+            {
+                ReadControllerJoints( pController);
+            }
+            else if( IsElement( "vertex_weights"))
+            {
+                ReadControllerWeights( pController);
+            }
+            else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) 
+        {
+            if( strcmp( mReader->getNodeName(), "controller") == 0)
+                break;
+            else if( strcmp( mReader->getNodeName(), "skin") != 0)
+                ThrowException( "Expected end of <controller> element.");
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the joint definitions for the given controller
+void ColladaParser::ReadControllerJoints( Collada::Controller& pController)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) 
+        {
+            // Input channels for joint data. Two possible semantics: "JOINT" and "INV_BIND_MATRIX"
+            if( IsElement( "input"))
+            {
+                int indexSemantic = GetAttribute( "semantic");
+                const char* attrSemantic = mReader->getAttributeValue( indexSemantic);
+                int indexSource = GetAttribute( "source");
+                const char* attrSource = mReader->getAttributeValue( indexSource);
+
+                // local URLS always start with a '#'. We don't support global URLs
+                if( attrSource[0] != '#')
+                    ThrowException( boost::str( boost::format( "Unsupported URL format in \"%s\" in source attribute of <joints> data <input> element") % attrSource));
+                attrSource++;
+
+                // parse source URL to corresponding source
+                if( strcmp( attrSemantic, "JOINT") == 0)
+                    pController.mJointNameSource = attrSource;
+                else if( strcmp( attrSemantic, "INV_BIND_MATRIX") == 0)
+                    pController.mJointOffsetMatrixSource = attrSource;
+                else
+                    ThrowException( boost::str( boost::format( "Unknown semantic \"%s\" in <joints> data <input> element") % attrSemantic));
+
+                // skip inner data, if present
+                if( !mReader->isEmptyElement())
+                    SkipElement();
+            }
+            else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) 
+        {
+            if( strcmp( mReader->getNodeName(), "joints") != 0)
+                ThrowException( "Expected end of <joints> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the joint weights for the given controller
+void ColladaParser::ReadControllerWeights( Collada::Controller& pController)
+{
+    // read vertex count from attributes and resize the array accordingly
+    int indexCount = GetAttribute( "count");
+    size_t vertexCount = (size_t) mReader->getAttributeValueAsInt( indexCount);
+    pController.mWeightCounts.resize( vertexCount);
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) 
+        {
+            // Input channels for weight data. Two possible semantics: "JOINT" and "WEIGHT"
+            if( IsElement( "input") && vertexCount > 0 )
+            {
+                InputChannel channel;
+
+                int indexSemantic = GetAttribute( "semantic");
+                const char* attrSemantic = mReader->getAttributeValue( indexSemantic);
+                int indexSource = GetAttribute( "source");
+                const char* attrSource = mReader->getAttributeValue( indexSource);
+                int indexOffset = TestAttribute( "offset");
+                if( indexOffset >= 0)
+                    channel.mOffset = mReader->getAttributeValueAsInt( indexOffset);
+
+                // local URLS always start with a '#'. We don't support global URLs
+                if( attrSource[0] != '#')
+                    ThrowException( boost::str( boost::format( "Unsupported URL format in \"%s\" in source attribute of <vertex_weights> data <input> element") % attrSource));
+                channel.mAccessor = attrSource + 1;
+
+                // parse source URL to corresponding source
+                if( strcmp( attrSemantic, "JOINT") == 0)
+                    pController.mWeightInputJoints = channel;
+                else if( strcmp( attrSemantic, "WEIGHT") == 0)
+                    pController.mWeightInputWeights = channel;
+                else
+                    ThrowException( boost::str( boost::format( "Unknown semantic \"%s\" in <vertex_weights> data <input> element") % attrSemantic));
+
+                // skip inner data, if present
+                if( !mReader->isEmptyElement())
+                    SkipElement();
+            }
+            else if( IsElement( "vcount") && vertexCount > 0 )
+            {
+                // read weight count per vertex
+                const char* text = GetTextContent();
+                size_t numWeights = 0;
+                for( std::vector<size_t>::iterator it = pController.mWeightCounts.begin(); it != pController.mWeightCounts.end(); ++it)
+                {
+                    if( *text == 0)
+                        ThrowException( "Out of data while reading <vcount>");
+
+                    *it = strtoul10( text, &text);
+                    numWeights += *it;
+                    SkipSpacesAndLineEnd( &text);
+                }
+
+                TestClosing( "vcount");
+
+                // reserve weight count 
+                pController.mWeights.resize( numWeights);
+            }
+            else if( IsElement( "v") && vertexCount > 0 )
+            {
+                // read JointIndex - WeightIndex pairs
+                const char* text = GetTextContent();
+
+                for( std::vector< std::pair<size_t, size_t> >::iterator it = pController.mWeights.begin(); it != pController.mWeights.end(); ++it)
+                {
+                    if( *text == 0)
+                        ThrowException( "Out of data while reading <vertex_weights>");
+                    it->first = strtoul10( text, &text);
+                    SkipSpacesAndLineEnd( &text);
+                    if( *text == 0)
+                        ThrowException( "Out of data while reading <vertex_weights>");
+                    it->second = strtoul10( text, &text);
+                    SkipSpacesAndLineEnd( &text);
+                }
+
+                TestClosing( "v");
+            }
+            else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) 
+        {
+            if( strcmp( mReader->getNodeName(), "vertex_weights") != 0)
+                ThrowException( "Expected end of <vertex_weights> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the image library contents
+void ColladaParser::ReadImageLibrary()
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if( IsElement( "image"))
+            {
+                // read ID. Another entry which is "optional" by design but obligatory in reality
+                int attrID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( attrID);
+
+                // create an entry and store it in the library under its ID
+                mImageLibrary[id] = Image();
+
+                // read on from there
+                ReadImage( mImageLibrary[id]);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "library_images") != 0)
+                ThrowException( "Expected end of <library_images> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an image entry into the given image
+void ColladaParser::ReadImage( Collada::Image& pImage)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT){
+            // Need to run different code paths here, depending on the Collada XSD version
+            if (IsElement("image")) {
+                SkipElement();
+            }
+            else if(  IsElement( "init_from"))
+            {
+                if (mFormat == FV_1_4_n) 
+                {
+                    // FIX: C4D exporter writes empty <init_from/> tags
+                    if (!mReader->isEmptyElement()) {
+                        // element content is filename - hopefully
+                        const char* sz = TestTextContent();
+                        if (sz)pImage.mFileName = sz;
+                        TestClosing( "init_from");
+                    }
+                    if (!pImage.mFileName.length()) {
+                        pImage.mFileName = "unknown_texture";
+                    }
+                }
+                else if (mFormat == FV_1_5_n) 
+                {
+                    // make sure we skip over mip and array initializations, which
+                    // we don't support, but which could confuse the loader if 
+                    // they're not skipped.
+                    int attrib = TestAttribute("array_index");
+                    if (attrib != -1 && mReader->getAttributeValueAsInt(attrib) > 0) {
+                        DefaultLogger::get()->warn("Collada: Ignoring texture array index");
+                        continue;
+                    }
+
+                    attrib = TestAttribute("mip_index");
+                    if (attrib != -1 && mReader->getAttributeValueAsInt(attrib) > 0) {
+                        DefaultLogger::get()->warn("Collada: Ignoring MIP map layer");
+                        continue;
+                    }
+
+                    // TODO: correctly jump over cube and volume maps?
+                }
+            }
+            else if (mFormat == FV_1_5_n) 
+            {
+                if( IsElement( "ref"))
+                {
+                    // element content is filename - hopefully
+                    const char* sz = TestTextContent();
+                    if (sz)pImage.mFileName = sz;
+                    TestClosing( "ref");
+                } 
+                else if( IsElement( "hex") && !pImage.mFileName.length())
+                {
+                    // embedded image. get format
+                    const int attrib = TestAttribute("format");
+                    if (-1 == attrib) 
+                        DefaultLogger::get()->warn("Collada: Unknown image file format");
+                    else pImage.mEmbeddedFormat = mReader->getAttributeValue(attrib);
+
+                    const char* data = GetTextContent();
+
+                    // hexadecimal-encoded binary octets. First of all, find the
+                    // required buffer size to reserve enough storage.
+                    const char* cur = data;
+                    while (!IsSpaceOrNewLine(*cur)) cur++;
+
+                    const unsigned int size = (unsigned int)(cur-data) * 2;
+                    pImage.mImageData.resize(size);
+                    for (unsigned int i = 0; i < size;++i) 
+                        pImage.mImageData[i] = HexOctetToDecimal(data+(i<<1));
+
+                    TestClosing( "hex");
+                } 
+            }
+            else    
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "image") == 0)
+                break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the material library
+void ColladaParser::ReadMaterialLibrary()
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    std::map<std::string, int> names;
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) 
+        {
+            if( IsElement( "material"))
+            {
+                // read ID. By now you propably know my opinion about this "specification"
+                int attrID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( attrID);
+
+                std::string name;
+                int attrName = TestAttribute("name");
+                if (attrName >= 0)
+                    name = mReader->getAttributeValue( attrName);
+
+                // create an entry and store it in the library under its ID
+                mMaterialLibrary[id] = Material();
+
+                if( !name.empty())
+                {
+                    std::map<std::string, int>::iterator it = names.find( name);
+                    if( it != names.end())
+                    {
+                        std::ostringstream strStream;
+                        strStream << ++it->second;
+                        name.append( " " + strStream.str());
+                    }
+                    else
+                    {
+                        names[name] = 0;
+                    }
+
+                    mMaterialLibrary[id].mName = name;
+                }
+
+                ReadMaterial( mMaterialLibrary[id]);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) 
+        {
+            if( strcmp( mReader->getNodeName(), "library_materials") != 0)
+                ThrowException( "Expected end of <library_materials> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the light library
+void ColladaParser::ReadLightLibrary()
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if( IsElement( "light"))
+            {
+                // read ID. By now you propably know my opinion about this "specification"
+                int attrID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( attrID);
+
+                // create an entry and store it in the library under its ID
+                ReadLight(mLightLibrary[id] = Light());
+
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)    {
+            if( strcmp( mReader->getNodeName(), "library_lights") != 0)
+                ThrowException( "Expected end of <library_lights> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the camera library
+void ColladaParser::ReadCameraLibrary()
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if( IsElement( "camera"))
+            {
+                // read ID. By now you propably know my opinion about this "specification"
+                int attrID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( attrID);
+
+                // create an entry and store it in the library under its ID
+                Camera& cam = mCameraLibrary[id]; 
+                attrID = TestAttribute( "name");
+                if (attrID != -1) 
+                    cam.mName = mReader->getAttributeValue( attrID);
+
+                ReadCamera(cam);
+
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)    {
+            if( strcmp( mReader->getNodeName(), "library_cameras") != 0)
+                ThrowException( "Expected end of <library_cameras> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a material entry into the given material
+void ColladaParser::ReadMaterial( Collada::Material& pMaterial)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if (IsElement("material")) {
+                SkipElement();
+            }
+            else if( IsElement( "instance_effect"))
+            {
+                // referred effect by URL
+                int attrUrl = GetAttribute( "url");
+                const char* url = mReader->getAttributeValue( attrUrl);
+                if( url[0] != '#')
+                    ThrowException( "Unknown reference format");
+
+                pMaterial.mEffect = url+1;
+
+                SkipElement();
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "material") != 0)
+                ThrowException( "Expected end of <material> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a light entry into the given light
+void ColladaParser::ReadLight( Collada::Light& pLight)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if (IsElement("light")) {
+                SkipElement();
+            }
+            else if (IsElement("spot")) {
+                pLight.mType = aiLightSource_SPOT;
+            }
+            else if (IsElement("ambient")) {
+                pLight.mType = aiLightSource_AMBIENT;
+            }
+            else if (IsElement("directional")) {
+                pLight.mType = aiLightSource_DIRECTIONAL;
+            }
+            else if (IsElement("point")) {
+                pLight.mType = aiLightSource_POINT;
+            }
+            else if (IsElement("color")) {
+                // text content contains 3 floats
+                const char* content = GetTextContent();
+                  
+                content = fast_atoreal_move<float>( content, (float&)pLight.mColor.r);
+                SkipSpacesAndLineEnd( &content);
+                
+                content = fast_atoreal_move<float>( content, (float&)pLight.mColor.g);
+                SkipSpacesAndLineEnd( &content);
+
+                content = fast_atoreal_move<float>( content, (float&)pLight.mColor.b);
+                SkipSpacesAndLineEnd( &content);
+
+                TestClosing( "color");
+            }
+            else if (IsElement("constant_attenuation")) {
+                pLight.mAttConstant = ReadFloatFromTextContent();
+                TestClosing("constant_attenuation");
+            }
+            else if (IsElement("linear_attenuation")) {
+                pLight.mAttLinear = ReadFloatFromTextContent();
+                TestClosing("linear_attenuation");
+            }
+            else if (IsElement("quadratic_attenuation")) {
+                pLight.mAttQuadratic = ReadFloatFromTextContent();
+                TestClosing("quadratic_attenuation");
+            }
+            else if (IsElement("falloff_angle")) {
+                pLight.mFalloffAngle = ReadFloatFromTextContent();
+                TestClosing("falloff_angle");
+            }
+            else if (IsElement("falloff_exponent")) {
+                pLight.mFalloffExponent = ReadFloatFromTextContent();
+                TestClosing("falloff_exponent");
+            }
+            // FCOLLADA extensions 
+            // -------------------------------------------------------
+            else if (IsElement("outer_cone")) {
+                pLight.mOuterAngle = ReadFloatFromTextContent();
+                TestClosing("outer_cone");
+            }
+            // ... and this one is even deprecated
+            else if (IsElement("penumbra_angle")) {
+                pLight.mPenumbraAngle = ReadFloatFromTextContent();
+                TestClosing("penumbra_angle");
+            }
+            else if (IsElement("intensity")) {
+                pLight.mIntensity = ReadFloatFromTextContent();
+                TestClosing("intensity");
+            }
+            else if (IsElement("falloff")) {
+                pLight.mOuterAngle = ReadFloatFromTextContent();
+                TestClosing("falloff");
+            }
+            else if (IsElement("hotspot_beam")) {
+                pLight.mFalloffAngle = ReadFloatFromTextContent();
+                TestClosing("hotspot_beam");
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "light") == 0)
+                break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a camera entry into the given light
+void ColladaParser::ReadCamera( Collada::Camera& pCamera)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if (IsElement("camera")) {
+                SkipElement();
+            }
+            else if (IsElement("orthographic")) {
+                pCamera.mOrtho = true;
+            }
+            else if (IsElement("xfov") || IsElement("xmag")) {
+                pCamera.mHorFov = ReadFloatFromTextContent();
+                TestClosing((pCamera.mOrtho ? "xmag" : "xfov"));
+            }
+            else if (IsElement("yfov") || IsElement("ymag")) {
+                pCamera.mVerFov = ReadFloatFromTextContent();
+                TestClosing((pCamera.mOrtho ? "ymag" : "yfov"));
+            }
+            else if (IsElement("aspect_ratio")) {
+                pCamera.mAspect = ReadFloatFromTextContent();
+                TestClosing("aspect_ratio");
+            }
+            else if (IsElement("znear")) {
+                pCamera.mZNear = ReadFloatFromTextContent();
+                TestClosing("znear");
+            }
+            else if (IsElement("zfar")) {
+                pCamera.mZFar = ReadFloatFromTextContent();
+                TestClosing("zfar");
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "camera") == 0)
+                break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the effect library
+void ColladaParser::ReadEffectLibrary()
+{
+    if (mReader->isEmptyElement()) {
+        return;
+    }
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if( IsElement( "effect"))
+            {
+                // read ID. Do I have to repeat my ranting about "optional" attributes?
+                int attrID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( attrID);
+
+                // create an entry and store it in the library under its ID
+                mEffectLibrary[id] = Effect();
+                // read on from there
+                ReadEffect( mEffectLibrary[id]);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "library_effects") != 0)
+                ThrowException( "Expected end of <library_effects> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect entry into the given effect
+void ColladaParser::ReadEffect( Collada::Effect& pEffect)
+{
+    // for the moment we don't support any other type of effect.
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "profile_COMMON"))
+                ReadEffectProfileCommon( pEffect);
+            else
+                SkipElement();
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) 
+        {
+            if( strcmp( mReader->getNodeName(), "effect") != 0)
+                ThrowException( "Expected end of <effect> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an COMMON effect profile
+void ColladaParser::ReadEffectProfileCommon( Collada::Effect& pEffect)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) 
+        {
+            if( IsElement( "newparam"))    {
+                // save ID
+                int attrSID = GetAttribute( "sid");
+                std::string sid = mReader->getAttributeValue( attrSID);
+                pEffect.mParams[sid] = EffectParam();
+                ReadEffectParam( pEffect.mParams[sid]);
+            } 
+            else if( IsElement( "technique") || IsElement( "extra"))
+            {
+                // just syntactic sugar
+            }
+
+            else if( mFormat == FV_1_4_n && IsElement( "image"))
+            {
+                // read ID. Another entry which is "optional" by design but obligatory in reality
+                int attrID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( attrID);
+
+                // create an entry and store it in the library under its ID
+                mImageLibrary[id] = Image();
+
+                // read on from there
+                ReadImage( mImageLibrary[id]);
+            }
+
+            /* Shading modes */
+            else if( IsElement( "phong"))
+                pEffect.mShadeType = Shade_Phong;
+            else if( IsElement( "constant"))
+                pEffect.mShadeType = Shade_Constant;
+            else if( IsElement( "lambert"))
+                pEffect.mShadeType = Shade_Lambert;
+            else if( IsElement( "blinn"))
+                pEffect.mShadeType = Shade_Blinn;
+
+            /* Color + texture properties */
+            else if( IsElement( "emission"))
+                ReadEffectColor( pEffect.mEmissive, pEffect.mTexEmissive);
+            else if( IsElement( "ambient"))
+                ReadEffectColor( pEffect.mAmbient, pEffect.mTexAmbient);
+            else if( IsElement( "diffuse"))
+                ReadEffectColor( pEffect.mDiffuse, pEffect.mTexDiffuse);
+            else if( IsElement( "specular"))
+                ReadEffectColor( pEffect.mSpecular, pEffect.mTexSpecular);
+            else if( IsElement( "reflective")) {
+                ReadEffectColor( pEffect.mReflective, pEffect.mTexReflective);
+            }
+            else if( IsElement( "transparent")) {
+                ReadEffectColor( pEffect.mTransparent,pEffect.mTexTransparent);
+            }
+            else if( IsElement( "shininess"))
+                ReadEffectFloat( pEffect.mShininess);
+            else if( IsElement( "reflectivity"))
+                ReadEffectFloat( pEffect.mReflectivity);
+
+            /* Single scalar properties */
+            else if( IsElement( "transparency"))
+                ReadEffectFloat( pEffect.mTransparency);
+            else if( IsElement( "index_of_refraction"))
+                ReadEffectFloat( pEffect.mRefractIndex);
+
+            // GOOGLEEARTH/OKINO extensions 
+            // -------------------------------------------------------
+            else if( IsElement( "double_sided"))
+                pEffect.mDoubleSided = ReadBoolFromTextContent();
+
+            // FCOLLADA extensions
+            // -------------------------------------------------------
+            else if( IsElement( "bump")) {
+                aiColor4D dummy;
+                ReadEffectColor( dummy,pEffect.mTexBump);
+            }
+
+            // MAX3D extensions
+            // -------------------------------------------------------
+            else if( IsElement( "wireframe"))    {
+                pEffect.mWireframe = ReadBoolFromTextContent();
+                TestClosing( "wireframe");
+            }
+            else if( IsElement( "faceted"))    {
+                pEffect.mFaceted = ReadBoolFromTextContent();
+                TestClosing( "faceted");
+            }
+            else 
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "profile_COMMON") == 0)
+            {
+                break;
+            } 
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Read texture wrapping + UV transform settings from a profile==Maya chunk
+void ColladaParser::ReadSamplerProperties( Sampler& out )
+{
+    if (mReader->isEmptyElement()) {
+        return;
+    }
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+
+            // MAYA extensions
+            // -------------------------------------------------------
+            if( IsElement( "wrapU"))        {
+                out.mWrapU = ReadBoolFromTextContent();
+                TestClosing( "wrapU");
+            }
+            else if( IsElement( "wrapV"))    {
+                out.mWrapV = ReadBoolFromTextContent();
+                TestClosing( "wrapV");
+            }
+            else if( IsElement( "mirrorU"))        {
+                out.mMirrorU = ReadBoolFromTextContent();
+                TestClosing( "mirrorU");
+            }
+            else if( IsElement( "mirrorV"))    {
+                out.mMirrorV = ReadBoolFromTextContent();
+                TestClosing( "mirrorV");
+            }
+            else if( IsElement( "repeatU"))    {
+                out.mTransform.mScaling.x = ReadFloatFromTextContent();
+                TestClosing( "repeatU");
+            }
+            else if( IsElement( "repeatV"))    {
+                out.mTransform.mScaling.y = ReadFloatFromTextContent();
+                TestClosing( "repeatV");
+            }
+            else if( IsElement( "offsetU"))    {
+                out.mTransform.mTranslation.x = ReadFloatFromTextContent();
+                TestClosing( "offsetU");
+            }
+            else if( IsElement( "offsetV"))    {
+                out.mTransform.mTranslation.y = ReadFloatFromTextContent();
+                TestClosing( "offsetV");
+            }
+            else if( IsElement( "rotateUV"))    {
+                out.mTransform.mRotation = ReadFloatFromTextContent();
+                TestClosing( "rotateUV");
+            }
+            else if( IsElement( "blend_mode"))    {
+                
+                const char* sz = GetTextContent();
+                // http://www.feelingsoftware.com/content/view/55/72/lang,en/
+                // NONE, OVER, IN, OUT, ADD, SUBTRACT, MULTIPLY, DIFFERENCE, LIGHTEN, DARKEN, SATURATE, DESATURATE and ILLUMINATE
+                if (0 == ASSIMP_strincmp(sz,"ADD",3)) 
+                    out.mOp = aiTextureOp_Add;
+
+                else if (0 == ASSIMP_strincmp(sz,"SUBTRACT",8)) 
+                    out.mOp = aiTextureOp_Subtract;
+
+                else if (0 == ASSIMP_strincmp(sz,"MULTIPLY",8)) 
+                    out.mOp = aiTextureOp_Multiply;
+
+                else  {
+                    DefaultLogger::get()->warn("Collada: Unsupported MAYA texture blend mode");
+                }
+                TestClosing( "blend_mode");
+            }
+            // OKINO extensions
+            // -------------------------------------------------------
+            else if( IsElement( "weighting"))    {
+                out.mWeighting = ReadFloatFromTextContent();
+                TestClosing( "weighting");
+            }
+            else if( IsElement( "mix_with_previous_layer"))    {
+                out.mMixWithPrevious = ReadFloatFromTextContent();
+                TestClosing( "mix_with_previous_layer");
+            }
+            // MAX3D extensions
+            // -------------------------------------------------------
+            else if( IsElement( "amount"))    {
+                out.mWeighting = ReadFloatFromTextContent();
+                TestClosing( "amount");
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            if( strcmp( mReader->getNodeName(), "technique") == 0)
+                break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect entry containing a color or a texture defining that color
+void ColladaParser::ReadEffectColor( aiColor4D& pColor, Sampler& pSampler)
+{
+    if (mReader->isEmptyElement())
+        return;
+
+    // Save current element name
+    const std::string curElem = mReader->getNodeName();
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if( IsElement( "color"))
+            {
+                // text content contains 4 floats
+                const char* content = GetTextContent(); 
+
+                content = fast_atoreal_move<float>( content, (float&)pColor.r);
+                SkipSpacesAndLineEnd( &content);
+
+                content = fast_atoreal_move<float>( content, (float&)pColor.g);
+                SkipSpacesAndLineEnd( &content);
+
+                content = fast_atoreal_move<float>( content, (float&)pColor.b);
+                SkipSpacesAndLineEnd( &content);
+
+                content = fast_atoreal_move<float>( content, (float&)pColor.a);
+                SkipSpacesAndLineEnd( &content);
+                TestClosing( "color");
+            } 
+            else if( IsElement( "texture"))
+            {
+                // get name of source textur/sampler
+                int attrTex = GetAttribute( "texture");
+                pSampler.mName = mReader->getAttributeValue( attrTex);
+
+                // get name of UV source channel. Specification demands it to be there, but some exporters
+                // don't write it. It will be the default UV channel in case it's missing.
+                attrTex = TestAttribute( "texcoord");
+                if( attrTex >= 0 )
+                      pSampler.mUVChannel = mReader->getAttributeValue( attrTex);
+                //SkipElement();
+
+                // as we've read texture, the color needs to be 1,1,1,1
+                pColor = aiColor4D(1.f, 1.f, 1.f, 1.f);
+            }
+            else if( IsElement( "technique"))
+            {
+                const int _profile = GetAttribute( "profile");
+                const char* profile = mReader->getAttributeValue( _profile );
+
+                // Some extensions are quite useful ... ReadSamplerProperties processes
+                // several extensions in MAYA, OKINO and MAX3D profiles.
+                if (!::strcmp(profile,"MAYA") || !::strcmp(profile,"MAX3D") || !::strcmp(profile,"OKINO"))
+                {
+                    // get more information on this sampler
+                    ReadSamplerProperties(pSampler);
+                }
+                else SkipElement();
+            }
+            else if( !IsElement( "extra"))
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END){
+            if (mReader->getNodeName() == curElem)
+                break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect entry containing a float
+void ColladaParser::ReadEffectFloat( float& pFloat)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT){
+            if( IsElement( "float"))
+            {
+                // text content contains a single floats
+                const char* content = GetTextContent();
+                content = fast_atoreal_move<float>( content, pFloat);
+                SkipSpacesAndLineEnd( &content);
+
+                TestClosing( "float");
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END){
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect parameter specification of any kind 
+void ColladaParser::ReadEffectParam( Collada::EffectParam& pParam)
+{
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+            if( IsElement( "surface"))
+            {
+                // image ID given inside <init_from> tags
+                TestOpening( "init_from");
+                const char* content = GetTextContent();
+                pParam.mType = Param_Surface;
+                pParam.mReference = content;
+                TestClosing( "init_from");
+
+                // don't care for remaining stuff
+                SkipElement( "surface");
+            } 
+            else if( IsElement( "sampler2D"))
+            {
+                // surface ID is given inside <source> tags
+                TestOpening( "source");
+                const char* content = GetTextContent();
+                pParam.mType = Param_Sampler;
+                pParam.mReference = content;
+                TestClosing( "source");
+
+                // don't care for remaining stuff
+                SkipElement( "sampler2D");
+            } else
+            {
+                // ignore unknown element
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the geometry library contents
+void ColladaParser::ReadGeometryLibrary()
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "geometry"))
+            {
+                // read ID. Another entry which is "optional" by design but obligatory in reality
+                int indexID = GetAttribute( "id");
+                std::string id = mReader->getAttributeValue( indexID);
+
+                // TODO: (thom) support SIDs
+                // ai_assert( TestAttribute( "sid") == -1);
+
+                // create a mesh and store it in the library under its ID
+                Mesh* mesh = new Mesh;
+                mMeshLibrary[id] = mesh;
+                
+                // read the mesh name if it exists
+                const int nameIndex = TestAttribute("name");
+                if(nameIndex != -1)
+                {
+                    mesh->mName = mReader->getAttributeValue(nameIndex);
+                }
+
+                // read on from there
+                ReadGeometry( mesh);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "library_geometries") != 0)
+                ThrowException( "Expected end of <library_geometries> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a geometry from the geometry library.
+void ColladaParser::ReadGeometry( Collada::Mesh* pMesh)
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "mesh"))
+            {
+                // read on from there
+                ReadMesh( pMesh);
+            } else
+            {
+                // ignore the rest
+                SkipElement();
+            }
+        }
+        else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+        {
+            if( strcmp( mReader->getNodeName(), "geometry") != 0)
+                ThrowException( "Expected end of <geometry> element.");
+
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a mesh from the geometry library
+void ColladaParser::ReadMesh( Mesh* pMesh)
+{
+    if( mReader->isEmptyElement())
+        return;
+
+    while( mReader->read())
+    {
+        if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+        {
+            if( IsElement( "source"))
+            {
+                // we have professionals dealing with this
+                ReadSource();
+            }
+            else if( IsElement( "vertices"))
+            {
+                // read per-vertex mesh data
+                ReadVertexData( pMesh);
+            }
+            else if( IsElement( "triangles") || IsElement( "lines") || IsElement( "linestrips")
+            	|| IsElement( "polygons") || IsElement( "polylist") || IsElement( "trifans") || IsElement( "tristrips")) 
+			{
+				// read per-index mesh data and faces setup
+				ReadIndexData( pMesh);
+			} else
+			{
+				// ignore the rest
+				SkipElement();
+			}
+		}
+		else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+		{
+			if( strcmp( mReader->getNodeName(), "technique_common") == 0)
+			{
+				// end of another meaningless element - read over it
+			} 
+			else if( strcmp( mReader->getNodeName(), "mesh") == 0)
+			{
+				// end of <mesh> element - we're done here
+				break;
+			} else
+			{
+				// everything else should be punished
+				ThrowException( "Expected end of <mesh> element.");
+			}
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a source element 
+void ColladaParser::ReadSource()
+{
+	int indexID = GetAttribute( "id");
+	std::string sourceID = mReader->getAttributeValue( indexID);
+
+	while( mReader->read())
+	{
+		if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+		{
+			if( IsElement( "float_array") || IsElement( "IDREF_array") || IsElement( "Name_array"))
+			{
+				ReadDataArray();
+			}
+			else if( IsElement( "technique_common"))
+			{
+				// I don't care for your profiles 
+			}
+			else if( IsElement( "accessor"))
+			{
+				ReadAccessor( sourceID);
+			} else
+			{
+				// ignore the rest
+				SkipElement();
+			}
+		}
+		else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+		{
+			if( strcmp( mReader->getNodeName(), "source") == 0)
+			{
+				// end of <source> - we're done
+				break;
+			}
+			else if( strcmp( mReader->getNodeName(), "technique_common") == 0)
+			{
+				// end of another meaningless element - read over it
+			} else
+			{
+				// everything else should be punished
+				ThrowException( "Expected end of <source> element.");
+			}
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a data array holding a number of floats, and stores it in the global library
+void ColladaParser::ReadDataArray()
+{
+	std::string elmName = mReader->getNodeName();
+	bool isStringArray = (elmName == "IDREF_array" || elmName == "Name_array");
+  bool isEmptyElement = mReader->isEmptyElement();
+
+	// read attributes
+	int indexID = GetAttribute( "id");
+	std::string id = mReader->getAttributeValue( indexID);
+	int indexCount = GetAttribute( "count");
+	unsigned int count = (unsigned int) mReader->getAttributeValueAsInt( indexCount);
+	const char* content = TestTextContent();
+
+  // read values and store inside an array in the data library
+  mDataLibrary[id] = Data();
+  Data& data = mDataLibrary[id];
+  data.mIsStringArray = isStringArray;
+
+  // some exporters write empty data arrays, but we need to conserve them anyways because others might reference them
+  if (content) 
+  { 
+		if( isStringArray)
+		{
+			data.mStrings.reserve( count);
+			std::string s;
+
+			for( unsigned int a = 0; a < count; a++)
+			{
+				if( *content == 0)
+					ThrowException( "Expected more values while reading IDREF_array contents.");
+
+				s.clear();
+				while( !IsSpaceOrNewLine( *content))
+					s += *content++;
+				data.mStrings.push_back( s);
+
+				SkipSpacesAndLineEnd( &content);
+			}
+		} else
+		{
+			data.mValues.reserve( count);
+
+			for( unsigned int a = 0; a < count; a++)
+			{
+				if( *content == 0)
+					ThrowException( "Expected more values while reading float_array contents.");
+
+				float value;
+				// read a number
+				content = fast_atoreal_move<float>( content, value);
+				data.mValues.push_back( value);
+				// skip whitespace after it
+				SkipSpacesAndLineEnd( &content);
+			}
+		}
+	}
+
+  // test for closing tag
+  if( !isEmptyElement )
+    TestClosing( elmName.c_str());
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an accessor and stores it in the global library
+void ColladaParser::ReadAccessor( const std::string& pID)
+{
+	// read accessor attributes
+	int attrSource = GetAttribute( "source");
+	const char* source = mReader->getAttributeValue( attrSource);
+	if( source[0] != '#')
+		ThrowException( boost::str( boost::format( "Unknown reference format in url \"%s\" in source attribute of <accessor> element.") % source));
+	int attrCount = GetAttribute( "count");
+	unsigned int count = (unsigned int) mReader->getAttributeValueAsInt( attrCount);
+	int attrOffset = TestAttribute( "offset");
+	unsigned int offset = 0;
+	if( attrOffset > -1)
+		offset = (unsigned int) mReader->getAttributeValueAsInt( attrOffset);
+	int attrStride = TestAttribute( "stride");
+	unsigned int stride = 1;
+	if( attrStride > -1)
+		stride = (unsigned int) mReader->getAttributeValueAsInt( attrStride);
+
+	// store in the library under the given ID
+	mAccessorLibrary[pID] = Accessor();
+	Accessor& acc = mAccessorLibrary[pID];
+	acc.mCount = count;
+	acc.mOffset = offset;
+	acc.mStride = stride;
+	acc.mSource = source+1; // ignore the leading '#'
+	acc.mSize = 0; // gets incremented with every param
+
+	// and read the components
+	while( mReader->read())
+	{
+		if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+		{
+			if( IsElement( "param"))
+			{
+				// read data param
+				int attrName = TestAttribute( "name");
+				std::string name;
+				if( attrName > -1)
+				{
+					name = mReader->getAttributeValue( attrName);
+
+					// analyse for common type components and store it's sub-offset in the corresponding field
+
+					/* Cartesian coordinates */
+					if( name == "X") acc.mSubOffset[0] = acc.mParams.size();
+					else if( name == "Y") acc.mSubOffset[1] = acc.mParams.size();
+					else if( name == "Z") acc.mSubOffset[2] = acc.mParams.size();
+
+					/* RGBA colors */
+					else if( name == "R") acc.mSubOffset[0] = acc.mParams.size();
+					else if( name == "G") acc.mSubOffset[1] = acc.mParams.size();
+					else if( name == "B") acc.mSubOffset[2] = acc.mParams.size();
+					else if( name == "A") acc.mSubOffset[3] = acc.mParams.size();
+
+					/* UVWQ (STPQ) texture coordinates */
+					else if( name == "S") acc.mSubOffset[0] = acc.mParams.size();
+					else if( name == "T") acc.mSubOffset[1] = acc.mParams.size();
+					else if( name == "P") acc.mSubOffset[2] = acc.mParams.size();
+				//	else if( name == "Q") acc.mSubOffset[3] = acc.mParams.size(); 
+					/* 4D uv coordinates are not supported in Assimp */
+
+					/* Generic extra data, interpreted as UV data, too*/
+					else if( name == "U") acc.mSubOffset[0] = acc.mParams.size();
+					else if( name == "V") acc.mSubOffset[1] = acc.mParams.size();
+					//else
+					//	DefaultLogger::get()->warn( boost::str( boost::format( "Unknown accessor parameter \"%s\". Ignoring data channel.") % name));
+				}
+
+				// read data type
+				int attrType = TestAttribute( "type");
+				if( attrType > -1)
+				{
+					// for the moment we only distinguish between a 4x4 matrix and anything else. 
+					// TODO: (thom) I don't have a spec here at work. Check if there are other multi-value types
+					// which should be tested for here.
+					std::string type = mReader->getAttributeValue( attrType);
+					if( type == "float4x4")
+						acc.mSize += 16;
+					else 
+						acc.mSize += 1;
+				}
+
+				acc.mParams.push_back( name);
+
+				// skip remaining stuff of this element, if any
+				SkipElement();
+			} else
+			{
+				ThrowException( boost::str( boost::format( "Unexpected sub element <%s> in tag <accessor>") % mReader->getNodeName()));
+			}
+		} 
+		else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+		{
+			if( strcmp( mReader->getNodeName(), "accessor") != 0)
+				ThrowException( "Expected end of <accessor> element.");
+			break;
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads input declarations of per-vertex mesh data into the given mesh
+void ColladaParser::ReadVertexData( Mesh* pMesh)
+{
+	// extract the ID of the <vertices> element. Not that we care, but to catch strange referencing schemes we should warn about
+	int attrID= GetAttribute( "id");
+	pMesh->mVertexID = mReader->getAttributeValue( attrID);
+
+	// a number of <input> elements
+	while( mReader->read())
+	{
+		if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+		{
+			if( IsElement( "input"))
+			{
+				ReadInputChannel( pMesh->mPerVertexData);
+			} else
+			{
+				ThrowException( boost::str( boost::format( "Unexpected sub element <%s> in tag <vertices>") % mReader->getNodeName()));
+			}
+		} 
+		else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+		{
+			if( strcmp( mReader->getNodeName(), "vertices") != 0)
+				ThrowException( "Expected end of <vertices> element.");
+
+			break;
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads input declarations of per-index mesh data into the given mesh
+void ColladaParser::ReadIndexData( Mesh* pMesh)
+{
+	std::vector<size_t> vcount;
+	std::vector<InputChannel> perIndexData;
+
+	// read primitive count from the attribute
+	int attrCount = GetAttribute( "count");
+	size_t numPrimitives = (size_t) mReader->getAttributeValueAsInt( attrCount);
+	// some mesh types (e.g. tristrips) don't specify primitive count upfront,
+	// so we need to sum up the actual number of primitives while we read the <p>-tags
+	size_t actualPrimitives = 0;
+
+	// material subgroup
+	int attrMaterial = TestAttribute( "material");
+	SubMesh subgroup;
+	if( attrMaterial > -1)
+		subgroup.mMaterial = mReader->getAttributeValue( attrMaterial);
+
+	// distinguish between polys and triangles
+	std::string elementName = mReader->getNodeName();
+	PrimitiveType primType = Prim_Invalid;
+	if( IsElement( "lines"))
+		primType = Prim_Lines;
+	else if( IsElement( "linestrips"))
+		primType = Prim_LineStrip;
+	else if( IsElement( "polygons"))
+		primType = Prim_Polygon;
+	else if( IsElement( "polylist"))
+		primType = Prim_Polylist;
+	else if( IsElement( "triangles"))
+		primType = Prim_Triangles;
+	else if( IsElement( "trifans"))
+		primType = Prim_TriFans;
+	else if( IsElement( "tristrips"))
+		primType = Prim_TriStrips;
+
+	ai_assert( primType != Prim_Invalid);
+
+	// also a number of <input> elements, but in addition a <p> primitive collection and propably index counts for all primitives
+	while( mReader->read())
+	{
+		if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+		{
+			if( IsElement( "input"))
+			{
+				ReadInputChannel( perIndexData);
+			} 
+			else if( IsElement( "vcount"))
+			{
+				if( !mReader->isEmptyElement())
+				{
+					if (numPrimitives)	// It is possible to define a mesh without any primitives
+					{
+						// case <polylist> - specifies the number of indices for each polygon
+						const char* content = GetTextContent();
+						vcount.reserve( numPrimitives);
+						for( unsigned int a = 0; a < numPrimitives; a++)
+						{
+							if( *content == 0)
+								ThrowException( "Expected more values while reading <vcount> contents.");
+							// read a number
+							vcount.push_back( (size_t) strtoul10( content, &content));
+							// skip whitespace after it
+							SkipSpacesAndLineEnd( &content);
+						}
+					}
+
+					TestClosing( "vcount");
+				}
+			}
+			else if( IsElement( "p"))
+			{
+				if( !mReader->isEmptyElement())
+				{
+					// now here the actual fun starts - these are the indices to construct the mesh data from
+					actualPrimitives += ReadPrimitives(pMesh, perIndexData, numPrimitives, vcount, primType);
+				}
+			}
+			else if (IsElement("extra"))
+			{
+				SkipElement("extra");
+			} else
+			{
+				ThrowException( boost::str( boost::format( "Unexpected sub element <%s> in tag <%s>") % mReader->getNodeName() % elementName));
+			}
+		} 
+		else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+		{
+			if( mReader->getNodeName() != elementName)
+				ThrowException( boost::str( boost::format( "Expected end of <%s> element.") % elementName));
+
+			break;
+		}
+	}
+
+	// small sanity check
+	if (primType != Prim_TriFans && primType != Prim_TriStrips &&
+        primType != Prim_Lines) // this is ONLY to workaround a bug in SketchUp 15.3.331 where it writes the wrong 'count' when it writes out the 'lines'.
+		ai_assert(actualPrimitives == numPrimitives);
+
+	// only when we're done reading all <p> tags (and thus know the final vertex count) can we commit the submesh
+	subgroup.mNumFaces = actualPrimitives;
+	pMesh->mSubMeshes.push_back(subgroup);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a single input channel element and stores it in the given array, if valid 
+void ColladaParser::ReadInputChannel( std::vector<InputChannel>& poChannels)
+{
+	InputChannel channel;
+	
+	// read semantic
+	int attrSemantic = GetAttribute( "semantic");
+	std::string semantic = mReader->getAttributeValue( attrSemantic);
+	channel.mType = GetTypeForSemantic( semantic);
+
+	// read source
+	int attrSource = GetAttribute( "source");
+	const char* source = mReader->getAttributeValue( attrSource);
+	if( source[0] != '#')
+		ThrowException( boost::str( boost::format( "Unknown reference format in url \"%s\" in source attribute of <input> element.") % source));
+	channel.mAccessor = source+1; // skipping the leading #, hopefully the remaining text is the accessor ID only
+
+	// read index offset, if per-index <input>
+	int attrOffset = TestAttribute( "offset");
+	if( attrOffset > -1)
+		channel.mOffset = mReader->getAttributeValueAsInt( attrOffset);
+
+	// read set if texture coordinates
+	if(channel.mType == IT_Texcoord || channel.mType == IT_Color){
+		int attrSet = TestAttribute("set");
+		if(attrSet > -1){
+			attrSet = mReader->getAttributeValueAsInt( attrSet);
+			if(attrSet < 0)
+				ThrowException( boost::str( boost::format( "Invalid index \"%i\" in set attribute of <input> element") % (attrSet)));
+			
+			channel.mIndex = attrSet;
+		}
+	}
+
+	// store, if valid type
+	if( channel.mType != IT_Invalid)
+		poChannels.push_back( channel);
+
+	// skip remaining stuff of this element, if any
+	SkipElement();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a <p> primitive index list and assembles the mesh data into the given mesh
+size_t ColladaParser::ReadPrimitives( Mesh* pMesh, std::vector<InputChannel>& pPerIndexChannels,
+	size_t pNumPrimitives, const std::vector<size_t>& pVCount, PrimitiveType pPrimType)
+{
+	// determine number of indices coming per vertex 
+	// find the offset index for all per-vertex channels
+	size_t numOffsets = 1;
+	size_t perVertexOffset = SIZE_MAX; // invalid value
+	BOOST_FOREACH( const InputChannel& channel, pPerIndexChannels)
+	{
+		numOffsets = std::max( numOffsets, channel.mOffset+1);
+		if( channel.mType == IT_Vertex)
+			perVertexOffset = channel.mOffset;
+	}
+
+	// determine the expected number of indices 
+	size_t expectedPointCount = 0;
+	switch( pPrimType)
+	{
+		case Prim_Polylist:
+		{
+			BOOST_FOREACH( size_t i, pVCount)
+				expectedPointCount += i;
+			break;
+		}
+		case Prim_Lines:
+			expectedPointCount = 2 * pNumPrimitives;
+			break;
+		case Prim_Triangles:
+			expectedPointCount = 3 * pNumPrimitives;
+			break;
+		default:
+			// other primitive types don't state the index count upfront... we need to guess
+			break;
+	}
+
+	// and read all indices into a temporary array
+	std::vector<size_t> indices;
+	if( expectedPointCount > 0)
+		indices.reserve( expectedPointCount * numOffsets);
+
+	if (pNumPrimitives > 0)	// It is possible to not contain any indicies
+	{
+		const char* content = GetTextContent();
+		while( *content != 0)
+		{
+			// read a value. 
+			// Hack: (thom) Some exporters put negative indices sometimes. We just try to carry on anyways.
+			int value = std::max( 0, strtol10( content, &content));
+			indices.push_back( size_t( value));
+			// skip whitespace after it
+			SkipSpacesAndLineEnd( &content);
+		}
+	}
+
+	// complain if the index count doesn't fit
+    if( expectedPointCount > 0 && indices.size() != expectedPointCount * numOffsets) {
+        if (pPrimType == Prim_Lines) {
+            // HACK: We just fix this number since SketchUp 15.3.331 writes the wrong 'count' for 'lines'
+            ReportWarning( "Expected different index count in <p> element, %d instead of %d.", indices.size(), expectedPointCount * numOffsets);
+            pNumPrimitives = (indices.size() / numOffsets) / 2;
+        } else
+            ThrowException( "Expected different index count in <p> element.");
+
+    } else if( expectedPointCount == 0 && (indices.size() % numOffsets) != 0)
+		ThrowException( "Expected different index count in <p> element.");
+
+	// find the data for all sources
+  for( std::vector<InputChannel>::iterator it = pMesh->mPerVertexData.begin(); it != pMesh->mPerVertexData.end(); ++it)
+	{
+    InputChannel& input = *it;
+		if( input.mResolved)
+			continue;
+
+		// find accessor
+		input.mResolved = &ResolveLibraryReference( mAccessorLibrary, input.mAccessor);
+		// resolve accessor's data pointer as well, if neccessary
+		const Accessor* acc = input.mResolved;
+		if( !acc->mData)
+			acc->mData = &ResolveLibraryReference( mDataLibrary, acc->mSource);
+	}
+	// and the same for the per-index channels
+  for( std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it)
+  {
+    InputChannel& input = *it;
+		if( input.mResolved)
+			continue;
+
+		// ignore vertex pointer, it doesn't refer to an accessor
+		if( input.mType == IT_Vertex)
+		{
+			// warn if the vertex channel does not refer to the <vertices> element in the same mesh
+			if( input.mAccessor != pMesh->mVertexID)
+				ThrowException( "Unsupported vertex referencing scheme.");
+			continue;
+		}
+
+		// find accessor
+		input.mResolved = &ResolveLibraryReference( mAccessorLibrary, input.mAccessor);
+		// resolve accessor's data pointer as well, if neccessary
+		const Accessor* acc = input.mResolved;
+		if( !acc->mData)
+			acc->mData = &ResolveLibraryReference( mDataLibrary, acc->mSource);
+	}
+
+	// For continued primitives, the given count does not come all in one <p>, but only one primitive per <p>
+	size_t numPrimitives = pNumPrimitives;
+	if( pPrimType == Prim_TriFans || pPrimType == Prim_Polygon)
+		numPrimitives = 1;
+	// For continued primitives, the given count is actually the number of <p>'s inside the parent tag
+	if ( pPrimType == Prim_TriStrips){
+		size_t numberOfVertices = indices.size() / numOffsets;
+		numPrimitives = numberOfVertices - 2;
+	}
+
+	pMesh->mFaceSize.reserve( numPrimitives);
+	pMesh->mFacePosIndices.reserve( indices.size() / numOffsets);
+
+	size_t polylistStartVertex = 0;
+	for (size_t currentPrimitive = 0; currentPrimitive < numPrimitives; currentPrimitive++)
+	{
+		// determine number of points for this primitive
+		size_t numPoints = 0;
+		switch( pPrimType)
+		{
+			case Prim_Lines:
+				numPoints = 2;
+				for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+					CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+				break;
+			case Prim_Triangles:
+				numPoints = 3;
+				for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+					CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+				break;
+			case Prim_TriStrips:
+				numPoints = 3;
+				ReadPrimTriStrips(numOffsets, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+				break;
+			case Prim_Polylist: 
+				numPoints = pVCount[currentPrimitive];
+				for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+					CopyVertex(polylistStartVertex + currentVertex, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, 0, indices);
+				polylistStartVertex += numPoints;
+				break;
+			case Prim_TriFans: 
+			case Prim_Polygon:
+				numPoints = indices.size() / numOffsets;
+				for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+					CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+				break;
+			default:
+				// LineStrip is not supported due to expected index unmangling
+				ThrowException( "Unsupported primitive type.");
+				break;
+		}
+
+		// store the face size to later reconstruct the face from
+		pMesh->mFaceSize.push_back( numPoints);
+	}
+
+	// if I ever get my hands on that guy who invented this steaming pile of indirection...
+	TestClosing( "p");
+	return numPrimitives;
+}
+
+void ColladaParser::CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset, Mesh* pMesh, std::vector<InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices){
+	// calculate the base offset of the vertex whose attributes we ant to copy
+	size_t baseOffset = currentPrimitive * numOffsets * numPoints + currentVertex * numOffsets;
+
+	// don't overrun the boundaries of the index list
+	size_t maxIndexRequested = baseOffset + numOffsets - 1;
+	ai_assert(maxIndexRequested < indices.size());
+
+	// extract per-vertex channels using the global per-vertex offset
+	for (std::vector<InputChannel>::iterator it = pMesh->mPerVertexData.begin(); it != pMesh->mPerVertexData.end(); ++it)
+		ExtractDataObjectFromChannel(*it, indices[baseOffset + perVertexOffset], pMesh);
+	// and extract per-index channels using there specified offset
+	for (std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it)
+		ExtractDataObjectFromChannel(*it, indices[baseOffset + it->mOffset], pMesh);
+
+	// store the vertex-data index for later assignment of bone vertex weights
+	pMesh->mFacePosIndices.push_back(indices[baseOffset + perVertexOffset]);
+}
+
+void ColladaParser::ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Mesh* pMesh, std::vector<InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices){
+	if (currentPrimitive % 2 != 0){
+		//odd tristrip triangles need their indices mangled, to preserve winding direction
+		CopyVertex(1, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+		CopyVertex(0, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+		CopyVertex(2, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+	}
+	else {//for non tristrips or even tristrip triangles
+		CopyVertex(0, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+		CopyVertex(1, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+		CopyVertex(2, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Extracts a single object from an input channel and stores it in the appropriate mesh data array 
+void ColladaParser::ExtractDataObjectFromChannel( const InputChannel& pInput, size_t pLocalIndex, Mesh* pMesh)
+{
+	// ignore vertex referrer - we handle them that separate
+	if( pInput.mType == IT_Vertex)
+		return;
+
+	const Accessor& acc = *pInput.mResolved;
+	if( pLocalIndex >= acc.mCount)
+		ThrowException( boost::str( boost::format( "Invalid data index (%d/%d) in primitive specification") % pLocalIndex % acc.mCount));
+
+	// get a pointer to the start of the data object referred to by the accessor and the local index
+	const float* dataObject = &(acc.mData->mValues[0]) + acc.mOffset + pLocalIndex* acc.mStride;
+
+	// assemble according to the accessors component sub-offset list. We don't care, yet,
+	// what kind of object exactly we're extracting here
+	float obj[4];
+	for( size_t c = 0; c < 4; ++c)
+		obj[c] = dataObject[acc.mSubOffset[c]];
+
+	// now we reinterpret it according to the type we're reading here
+	switch( pInput.mType)
+	{
+		case IT_Position: // ignore all position streams except 0 - there can be only one position
+			if( pInput.mIndex == 0)
+				pMesh->mPositions.push_back( aiVector3D( obj[0], obj[1], obj[2])); 
+			else 
+				DefaultLogger::get()->error("Collada: just one vertex position stream supported");
+			break;
+		case IT_Normal: 
+			// pad to current vertex count if necessary
+			if( pMesh->mNormals.size() < pMesh->mPositions.size()-1)
+				pMesh->mNormals.insert( pMesh->mNormals.end(), pMesh->mPositions.size() - pMesh->mNormals.size() - 1, aiVector3D( 0, 1, 0));
+
+			// ignore all normal streams except 0 - there can be only one normal
+			if( pInput.mIndex == 0)
+				pMesh->mNormals.push_back( aiVector3D( obj[0], obj[1], obj[2])); 
+			else 
+				DefaultLogger::get()->error("Collada: just one vertex normal stream supported");
+			break;
+		case IT_Tangent: 
+			// pad to current vertex count if necessary
+			if( pMesh->mTangents.size() < pMesh->mPositions.size()-1)
+				pMesh->mTangents.insert( pMesh->mTangents.end(), pMesh->mPositions.size() - pMesh->mTangents.size() - 1, aiVector3D( 1, 0, 0));
+
+			// ignore all tangent streams except 0 - there can be only one tangent
+			if( pInput.mIndex == 0)
+				pMesh->mTangents.push_back( aiVector3D( obj[0], obj[1], obj[2])); 
+			else 
+				DefaultLogger::get()->error("Collada: just one vertex tangent stream supported");
+			break;
+		case IT_Bitangent: 
+			// pad to current vertex count if necessary
+			if( pMesh->mBitangents.size() < pMesh->mPositions.size()-1)
+				pMesh->mBitangents.insert( pMesh->mBitangents.end(), pMesh->mPositions.size() - pMesh->mBitangents.size() - 1, aiVector3D( 0, 0, 1));
+
+			// ignore all bitangent streams except 0 - there can be only one bitangent
+			if( pInput.mIndex == 0)
+				pMesh->mBitangents.push_back( aiVector3D( obj[0], obj[1], obj[2])); 
+			else 
+				DefaultLogger::get()->error("Collada: just one vertex bitangent stream supported");
+			break;
+		case IT_Texcoord: 
+			// up to 4 texture coord sets are fine, ignore the others
+			if( pInput.mIndex < AI_MAX_NUMBER_OF_TEXTURECOORDS) 
+			{
+				// pad to current vertex count if necessary
+				if( pMesh->mTexCoords[pInput.mIndex].size() < pMesh->mPositions.size()-1)
+					pMesh->mTexCoords[pInput.mIndex].insert( pMesh->mTexCoords[pInput.mIndex].end(), 
+						pMesh->mPositions.size() - pMesh->mTexCoords[pInput.mIndex].size() - 1, aiVector3D( 0, 0, 0));
+
+				pMesh->mTexCoords[pInput.mIndex].push_back( aiVector3D( obj[0], obj[1], obj[2]));
+				if (0 != acc.mSubOffset[2] || 0 != acc.mSubOffset[3]) /* hack ... consider cleaner solution */
+					pMesh->mNumUVComponents[pInput.mIndex]=3;
+			}	else 
+			{
+				DefaultLogger::get()->error("Collada: too many texture coordinate sets. Skipping.");
+			}
+			break;
+		case IT_Color: 
+			// up to 4 color sets are fine, ignore the others
+			if( pInput.mIndex < AI_MAX_NUMBER_OF_COLOR_SETS)
+			{
+				// pad to current vertex count if necessary
+				if( pMesh->mColors[pInput.mIndex].size() < pMesh->mPositions.size()-1)
+					pMesh->mColors[pInput.mIndex].insert( pMesh->mColors[pInput.mIndex].end(), 
+						pMesh->mPositions.size() - pMesh->mColors[pInput.mIndex].size() - 1, aiColor4D( 0, 0, 0, 1));
+
+				aiColor4D result(0, 0, 0, 1);
+				for (size_t i = 0; i < pInput.mResolved->mSize; ++i)
+				{
+					result[i] = obj[pInput.mResolved->mSubOffset[i]];
+				}
+				pMesh->mColors[pInput.mIndex].push_back(result); 
+			} else 
+			{
+				DefaultLogger::get()->error("Collada: too many vertex color sets. Skipping.");
+			}
+
+			break;
+		default:
+			// IT_Invalid and IT_Vertex 
+			ai_assert(false && "shouldn't ever get here");
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the library of node hierarchies and scene parts
+void ColladaParser::ReadSceneLibrary()
+{
+	if( mReader->isEmptyElement())
+		return;
+
+	while( mReader->read())
+	{
+		if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
+		{
+			// a visual scene - generate root node under its ID and let ReadNode() do the recursive work
+			if( IsElement( "visual_scene"))
+			{
+				// read ID. Is optional according to the spec, but how on earth should a scene_instance refer to it then?
+				int indexID = GetAttribute( "id");
+				const char* attrID = mReader->getAttributeValue( indexID);
+
+				// read name if given. 
+				int indexName = TestAttribute( "name");
+				const char* attrName = "unnamed";
+				if( indexName > -1)
+					attrName = mReader->getAttributeValue( indexName);
+
+				// create a node and store it in the library under its ID
+				Node* node = new Node;
+				node->mID = attrID;
+				node->mName = attrName;
+				mNodeLibrary[node->mID] = node;
+
+				ReadSceneNode( node);
+			} else
+			{
+				// ignore the rest
+				SkipElement();
+			}
+		}
+		else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+		{
+			if( strcmp( mReader->getNodeName(), "library_visual_scenes") == 0)
+				//ThrowException( "Expected end of \"library_visual_scenes\" element.");
+
+			break;
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a scene node's contents including children and stores it in the given node
+void ColladaParser::ReadSceneNode( Node* pNode)
+{
+	// quit immediately on <bla/> elements
+	if( mReader->isEmptyElement())
+		return;
+
+	while( mReader->read())
+	{
+		if( mReader->getNodeType() == irr::io::EXN_ELEMENT) 
+		{
+			if( IsElement( "node"))
+			{
+				Node* child = new Node;
+				int attrID = TestAttribute( "id");
+				if( attrID > -1)
+					child->mID = mReader->getAttributeValue( attrID);
+				int attrSID = TestAttribute( "sid");
+				if( attrSID > -1)
+					child->mSID = mReader->getAttributeValue( attrSID);
+
+				int attrName = TestAttribute( "name");
+				if( attrName > -1)
+					child->mName = mReader->getAttributeValue( attrName);
+
+				// TODO: (thom) support SIDs
+				// ai_assert( TestAttribute( "sid") == -1);
+
+				if (pNode) 
+				{
+					pNode->mChildren.push_back( child);
+					child->mParent = pNode;
+				}
+				else 
+				{
+					// no parent node given, probably called from <library_nodes> element.
+					// create new node in node library
+					mNodeLibrary[child->mID] = child;
+				}
+
+				// read on recursively from there
+				ReadSceneNode( child);
+				continue;
+			}
+			// For any further stuff we need a valid node to work on
+			else if (!pNode)
+				continue;
+
+			if( IsElement( "lookat"))
+				ReadNodeTransformation( pNode, TF_LOOKAT);
+			else if( IsElement( "matrix"))
+				ReadNodeTransformation( pNode, TF_MATRIX);
+			else if( IsElement( "rotate"))
+				ReadNodeTransformation( pNode, TF_ROTATE);
+			else if( IsElement( "scale"))
+				ReadNodeTransformation( pNode, TF_SCALE);
+			else if( IsElement( "skew"))
+				ReadNodeTransformation( pNode, TF_SKEW);
+			else if( IsElement( "translate"))
+				ReadNodeTransformation( pNode, TF_TRANSLATE);
+			else if( IsElement( "render") && pNode->mParent == NULL && 0 == pNode->mPrimaryCamera.length())
+			{
+				// ... scene evaluation or, in other words, postprocessing pipeline,
+				// or, again in other words, a turing-complete description how to
+				// render a Collada scene. The only thing that is interesting for
+				// us is the primary camera.
+				int attrId = TestAttribute("camera_node");
+				if (-1 != attrId) 
+				{
+					const char* s = mReader->getAttributeValue(attrId);
+					if (s[0] != '#')
+						DefaultLogger::get()->error("Collada: Unresolved reference format of camera");
+					else 
+						pNode->mPrimaryCamera = s+1;
+				}
+			}
+			else if( IsElement( "instance_node")) 
+			{
+				// find the node in the library
+				int attrID = TestAttribute( "url");
+				if( attrID != -1) 
+				{
+					const char* s = mReader->getAttributeValue(attrID);
+					if (s[0] != '#')
+						DefaultLogger::get()->error("Collada: Unresolved reference format of node");
+					else 
+					{
+						pNode->mNodeInstances.push_back(NodeInstance());
+						pNode->mNodeInstances.back().mNode = s+1;
+					}
+				}
+			} 
+			else if( IsElement( "instance_geometry") || IsElement( "instance_controller"))
+			{
+				// Reference to a mesh or controller, with possible material associations
+				ReadNodeGeometry( pNode);
+			}
+			else if( IsElement( "instance_light")) 
+			{
+				// Reference to a light, name given in 'url' attribute
+				int attrID = TestAttribute("url");
+				if (-1 == attrID)
+					DefaultLogger::get()->warn("Collada: Expected url attribute in <instance_light> element");
+				else 
+				{
+					const char* url = mReader->getAttributeValue( attrID);
+					if( url[0] != '#')
+						ThrowException( "Unknown reference format in <instance_light> element");
+
+					pNode->mLights.push_back(LightInstance());
+					pNode->mLights.back().mLight = url+1;
+				}
+			}
+			else if( IsElement( "instance_camera")) 
+			{
+				// Reference to a camera, name given in 'url' attribute
+				int attrID = TestAttribute("url");
+				if (-1 == attrID)
+					DefaultLogger::get()->warn("Collada: Expected url attribute in <instance_camera> element");
+				else 
+				{
+					const char* url = mReader->getAttributeValue( attrID);
+					if( url[0] != '#')
+						ThrowException( "Unknown reference format in <instance_camera> element");
+
+					pNode->mCameras.push_back(CameraInstance());
+					pNode->mCameras.back().mCamera = url+1;
+				}
+			}
+			else
+			{
+				// skip everything else for the moment
+				SkipElement();
+			}
+		} 
+		else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+			break;
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a node transformation entry of the given type and adds it to the given node's transformation list.
+void ColladaParser::ReadNodeTransformation( Node* pNode, TransformType pType)
+{
+	if( mReader->isEmptyElement())
+		return;
+
+	std::string tagName = mReader->getNodeName();
+
+	Transform tf;
+	tf.mType = pType;
+	
+	// read SID
+	int indexSID = TestAttribute( "sid");
+	if( indexSID >= 0)
+		tf.mID = mReader->getAttributeValue( indexSID);
+
+	// how many parameters to read per transformation type
+	static const unsigned int sNumParameters[] = { 9, 4, 3, 3, 7, 16 };
+	const char* content = GetTextContent();
+
+	// read as many parameters and store in the transformation
+	for( unsigned int a = 0; a < sNumParameters[pType]; a++)
+	{
+		// read a number
+		content = fast_atoreal_move<float>( content, tf.f[a]);
+		// skip whitespace after it
+		SkipSpacesAndLineEnd( &content);
+	}
+
+	// place the transformation at the queue of the node
+	pNode->mTransforms.push_back( tf);
+
+	// and consume the closing tag
+	TestClosing( tagName.c_str());
+}
+
+// ------------------------------------------------------------------------------------------------
+// Processes bind_vertex_input and bind elements
+void ColladaParser::ReadMaterialVertexInputBinding( Collada::SemanticMappingTable& tbl)
+{
+	while( mReader->read())
+	{
+		if( mReader->getNodeType() == irr::io::EXN_ELEMENT)	{
+			if( IsElement( "bind_vertex_input"))
+			{
+				Collada::InputSemanticMapEntry vn;
+
+				// effect semantic
+				int n = GetAttribute("semantic");
+				std::string s = mReader->getAttributeValue(n);
+
+				// input semantic
+				n = GetAttribute("input_semantic");
+				vn.mType = GetTypeForSemantic( mReader->getAttributeValue(n) );
+				
+				// index of input set
+				n = TestAttribute("input_set");
+				if (-1 != n)
+					vn.mSet = mReader->getAttributeValueAsInt(n);
+
+				tbl.mMap[s] = vn;
+			} 
+			else if( IsElement( "bind")) {
+				DefaultLogger::get()->warn("Collada: Found unsupported <bind> element");
+			}
+		} 
+		else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)	{
+			if( strcmp( mReader->getNodeName(), "instance_material") == 0)
+				break;
+		} 
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a mesh reference in a node and adds it to the node's mesh list
+void ColladaParser::ReadNodeGeometry( Node* pNode)
+{
+	// referred mesh is given as an attribute of the <instance_geometry> element
+	int attrUrl = GetAttribute( "url");
+	const char* url = mReader->getAttributeValue( attrUrl);
+	if( url[0] != '#')
+		ThrowException( "Unknown reference format");
+	
+	Collada::MeshInstance instance;
+	instance.mMeshOrController = url+1; // skipping the leading #
+
+	if( !mReader->isEmptyElement())
+	{
+		// read material associations. Ignore additional elements inbetween
+		while( mReader->read())
+		{
+			if( mReader->getNodeType() == irr::io::EXN_ELEMENT)	
+			{
+				if( IsElement( "instance_material"))
+				{
+					// read ID of the geometry subgroup and the target material
+					int attrGroup = GetAttribute( "symbol");
+					std::string group = mReader->getAttributeValue( attrGroup);
+					int attrMaterial = GetAttribute( "target");
+					const char* urlMat = mReader->getAttributeValue( attrMaterial);
+					Collada::SemanticMappingTable s;
+					if( urlMat[0] == '#')
+						urlMat++;
+
+					s.mMatName = urlMat;
+
+					// resolve further material details + THIS UGLY AND NASTY semantic mapping stuff
+					if( !mReader->isEmptyElement())
+						ReadMaterialVertexInputBinding(s);
+
+					// store the association
+					instance.mMaterials[group] = s;
+				} 
+			} 
+			else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)	
+			{
+				if( strcmp( mReader->getNodeName(), "instance_geometry") == 0 
+					|| strcmp( mReader->getNodeName(), "instance_controller") == 0)
+					break;
+			} 
+		}
+	}
+
+	// store it
+	pNode->mMeshes.push_back( instance);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the collada scene
+void ColladaParser::ReadScene()
+{
+	if( mReader->isEmptyElement())
+		return;
+
+	while( mReader->read())
+	{
+		if( mReader->getNodeType() == irr::io::EXN_ELEMENT)	{
+			if( IsElement( "instance_visual_scene"))
+			{
+				// should be the first and only occurence
+				if( mRootNode)
+					ThrowException( "Invalid scene containing multiple root nodes in <instance_visual_scene> element");
+
+				// read the url of the scene to instance. Should be of format "#some_name"
+				int urlIndex = GetAttribute( "url");
+				const char* url = mReader->getAttributeValue( urlIndex);
+				if( url[0] != '#')
+					ThrowException( "Unknown reference format in <instance_visual_scene> element");
+
+				// find the referred scene, skip the leading # 
+				NodeLibrary::const_iterator sit = mNodeLibrary.find( url+1);
+				if( sit == mNodeLibrary.end())
+					ThrowException( "Unable to resolve visual_scene reference \"" + std::string(url) + "\" in <instance_visual_scene> element.");
+				mRootNode = sit->second;
+			} else	{
+				SkipElement();
+			}
+		} 
+		else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END){
+			break;
+		} 
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Aborts the file reading with an exception
+AI_WONT_RETURN void ColladaParser::ThrowException( const std::string& pError) const
+{
+	throw DeadlyImportError( boost::str( boost::format( "Collada: %s - %s") % mFileName % pError));
+}
+
+void ColladaParser::ReportWarning(const char* msg,...)
+{
+    ai_assert(NULL != msg);
+    
+    va_list args;
+    va_start(args,msg);
+    
+    char szBuffer[3000];
+    const int iLen = vsprintf(szBuffer,msg,args);
+    ai_assert(iLen > 0);
+    
+    va_end(args);
+    DefaultLogger::get()->warn("Validation warning: " + std::string(szBuffer,iLen));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Skips all data until the end node of the current element
+void ColladaParser::SkipElement()
+{
+	// nothing to skip if it's an <element />
+	if( mReader->isEmptyElement())
+		return;
+
+	// reroute
+	SkipElement( mReader->getNodeName());
+}
+
+// ------------------------------------------------------------------------------------------------
+// Skips all data until the end node of the given element
+void ColladaParser::SkipElement( const char* pElement)
+{
+	// copy the current node's name because it'a pointer to the reader's internal buffer, 
+	// which is going to change with the upcoming parsing 
+	std::string element = pElement;
+	while( mReader->read())
+	{
+		if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
+			if( mReader->getNodeName() == element)
+				break;
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Tests for an opening element of the given name, throws an exception if not found
+void ColladaParser::TestOpening( const char* pName)
+{
+	// read element start
+	if( !mReader->read())
+		ThrowException( boost::str( boost::format( "Unexpected end of file while beginning of <%s> element.") % pName));
+	// whitespace in front is ok, just read again if found
+	if( mReader->getNodeType() == irr::io::EXN_TEXT)
+		if( !mReader->read())
+			ThrowException( boost::str( boost::format( "Unexpected end of file while reading beginning of <%s> element.") % pName));
+
+	if( mReader->getNodeType() != irr::io::EXN_ELEMENT || strcmp( mReader->getNodeName(), pName) != 0)
+		ThrowException( boost::str( boost::format( "Expected start of <%s> element.") % pName));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Tests for the closing tag of the given element, throws an exception if not found
+void ColladaParser::TestClosing( const char* pName)
+{
+	// check if we're already on the closing tag and return right away
+	if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END && strcmp( mReader->getNodeName(), pName) == 0)
+		return;
+
+	// if not, read some more
+	if( !mReader->read())
+		ThrowException( boost::str( boost::format( "Unexpected end of file while reading end of <%s> element.") % pName));
+	// whitespace in front is ok, just read again if found
+	if( mReader->getNodeType() == irr::io::EXN_TEXT)
+		if( !mReader->read())
+			ThrowException( boost::str( boost::format( "Unexpected end of file while reading end of <%s> element.") % pName));
+
+	// but this has the be the closing tag, or we're lost
+	if( mReader->getNodeType() != irr::io::EXN_ELEMENT_END || strcmp( mReader->getNodeName(), pName) != 0)
+		ThrowException( boost::str( boost::format( "Expected end of <%s> element.") % pName));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns the index of the named attribute or -1 if not found. Does not throw, therefore useful for optional attributes
+int ColladaParser::GetAttribute( const char* pAttr) const
+{
+	int index = TestAttribute( pAttr);
+	if( index != -1)
+		return index;
+
+	// attribute not found -> throw an exception
+	ThrowException( boost::str( boost::format( "Expected attribute \"%s\" for element <%s>.") % pAttr % mReader->getNodeName()));
+	return -1;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Tests the present element for the presence of one attribute, returns its index or throws an exception if not found
+int ColladaParser::TestAttribute( const char* pAttr) const
+{
+	for( int a = 0; a < mReader->getAttributeCount(); a++)
+		if( strcmp( mReader->getAttributeName( a), pAttr) == 0)
+			return a;
+
+	return -1;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the text contents of an element, throws an exception if not given. Skips leading whitespace.
+const char* ColladaParser::GetTextContent()
+{
+	const char* sz = TestTextContent();
+	if(!sz) {
+		ThrowException( "Invalid contents in element \"n\".");
+	}
+	return sz;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the text contents of an element, returns NULL if not given. Skips leading whitespace.
+const char* ColladaParser::TestTextContent()
+{
+	// present node should be the beginning of an element
+	if( mReader->getNodeType() != irr::io::EXN_ELEMENT || mReader->isEmptyElement())
+		return NULL;
+
+	// read contents of the element
+	if( !mReader->read() )
+		return NULL;
+	if( mReader->getNodeType() != irr::io::EXN_TEXT)
+		return NULL;
+
+	// skip leading whitespace
+	const char* text = mReader->getNodeData();
+	SkipSpacesAndLineEnd( &text);
+
+	return text;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Calculates the resulting transformation fromm all the given transform steps
+aiMatrix4x4 ColladaParser::CalculateResultTransform( const std::vector<Transform>& pTransforms) const
+{
+	aiMatrix4x4 res;
+
+	for( std::vector<Transform>::const_iterator it = pTransforms.begin(); it != pTransforms.end(); ++it)
+	{
+		const Transform& tf = *it;
+		switch( tf.mType)
+		{
+			case TF_LOOKAT:
+      {
+        aiVector3D pos( tf.f[0], tf.f[1], tf.f[2]);
+        aiVector3D dstPos( tf.f[3], tf.f[4], tf.f[5]);
+        aiVector3D up = aiVector3D( tf.f[6], tf.f[7], tf.f[8]).Normalize();
+        aiVector3D dir = aiVector3D( dstPos - pos).Normalize();
+        aiVector3D right = (dir ^ up).Normalize();
+
+        res *= aiMatrix4x4( 
+          right.x, up.x, -dir.x, pos.x, 
+          right.y, up.y, -dir.y, pos.y,
+          right.z, up.z, -dir.z, pos.z,
+          0, 0, 0, 1);
+				break;
+      }
+			case TF_ROTATE:
+			{
+				aiMatrix4x4 rot;
+				float angle = tf.f[3] * float( AI_MATH_PI) / 180.0f;
+				aiVector3D axis( tf.f[0], tf.f[1], tf.f[2]);
+				aiMatrix4x4::Rotation( angle, axis, rot);
+				res *= rot;
+				break;
+			}
+			case TF_TRANSLATE:
+			{
+				aiMatrix4x4 trans;
+				aiMatrix4x4::Translation( aiVector3D( tf.f[0], tf.f[1], tf.f[2]), trans);
+				res *= trans;
+				break;
+			}
+			case TF_SCALE:
+			{
+				aiMatrix4x4 scale( tf.f[0], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[1], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[2], 0.0f, 
+					0.0f, 0.0f, 0.0f, 1.0f);
+				res *= scale;
+				break;
+			}
+			case TF_SKEW:
+				// TODO: (thom)
+				ai_assert( false);
+				break;
+			case TF_MATRIX:
+			{
+				aiMatrix4x4 mat( tf.f[0], tf.f[1], tf.f[2], tf.f[3], tf.f[4], tf.f[5], tf.f[6], tf.f[7],
+					tf.f[8], tf.f[9], tf.f[10], tf.f[11], tf.f[12], tf.f[13], tf.f[14], tf.f[15]);
+				res *= mat;
+				break;
+			}
+			default: 
+				ai_assert( false);
+				break;
+		}
+	}
+
+	return res;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Determines the input data type for the given semantic string
+Collada::InputType ColladaParser::GetTypeForSemantic( const std::string& pSemantic)
+{
+	if( pSemantic == "POSITION")
+		return IT_Position;
+	else if( pSemantic == "TEXCOORD")
+		return IT_Texcoord;
+	else if( pSemantic == "NORMAL")
+		return IT_Normal;
+	else if( pSemantic == "COLOR")
+		return IT_Color;
+	else if( pSemantic == "VERTEX")
+		return IT_Vertex;
+	else if( pSemantic == "BINORMAL" || pSemantic ==  "TEXBINORMAL")
+		return IT_Bitangent;
+	else if( pSemantic == "TANGENT" || pSemantic == "TEXTANGENT")
+		return IT_Tangent;
+
+	DefaultLogger::get()->warn( boost::str( boost::format( "Unknown vertex input type \"%s\". Ignoring.") % pSemantic));
+	return IT_Invalid;
+}
+
+#endif // !! ASSIMP_BUILD_NO_DAE_IMPORTER

code/ColladaParser.cpp

@@ -47,6 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER
 
 #include <sstream>
+#include <stdarg.h>
 #include "ColladaParser.h"
 #include "fast_atof.h"
 #include "ParsingUtils.h"
@@ -1998,7 +1999,8 @@ void ColladaParser::ReadIndexData( Mesh* pMesh)
     }
 
 #ifdef ASSIMP_BUILD_DEBUG
-    if (primType != Prim_TriFans && primType != Prim_TriStrips) {
+	if (primType != Prim_TriFans && primType != Prim_TriStrips &&
+        primType != Prim_Lines) { // this is ONLY to workaround a bug in SketchUp 15.3.331 where it writes the wrong 'count' when it writes out the 'lines'.
         ai_assert(actualPrimitives == numPrimitives);
     }
 #endif
@@ -2107,13 +2109,19 @@ size_t ColladaParser::ReadPrimitives( Mesh* pMesh, std::vector<InputChannel>& pP
         }
     }
 
-    // complain if the index count doesn't fit
-    if( expectedPointCount > 0 && indices.size() != expectedPointCount * numOffsets)
-        ThrowException( "Expected different index count in <p> element.");
-    else if( expectedPointCount == 0 && (indices.size() % numOffsets) != 0)
-        ThrowException( "Expected different index count in <p> element.");
+	// complain if the index count doesn't fit
+    if( expectedPointCount > 0 && indices.size() != expectedPointCount * numOffsets) {
+        if (pPrimType == Prim_Lines) {
+            // HACK: We just fix this number since SketchUp 15.3.331 writes the wrong 'count' for 'lines'
+            ReportWarning( "Expected different index count in <p> element, %d instead of %d.", indices.size(), expectedPointCount * numOffsets);
+            pNumPrimitives = (indices.size() / numOffsets) / 2;
+        } else
+            ThrowException( "Expected different index count in <p> element.");
+
+    } else if( expectedPointCount == 0 && (indices.size() % numOffsets) != 0)
+		ThrowException( "Expected different index count in <p> element.");
 
-    // find the data for all sources
+	// find the data for all sources
   for( std::vector<InputChannel>::iterator it = pMesh->mPerVertexData.begin(); it != pMesh->mPerVertexData.end(); ++it)
     {
     InputChannel& input = *it;
@@ -2712,6 +2720,21 @@ AI_WONT_RETURN void ColladaParser::ThrowException( const std::string& pError) co
 {
     throw DeadlyImportError( boost::str( boost::format( "Collada: %s - %s") % mFileName % pError));
 }
+void ColladaParser::ReportWarning(const char* msg,...)
+{
+    ai_assert(NULL != msg);
+    
+    va_list args;
+    va_start(args,msg);
+    
+    char szBuffer[3000];
+    const int iLen = vsprintf(szBuffer,msg,args);
+    ai_assert(iLen > 0);
+    
+    va_end(args);
+    DefaultLogger::get()->warn("Validation warning: " + std::string(szBuffer,iLen));
+}
+
 
 // ------------------------------------------------------------------------------------------------
 // Skips all data until the end node of the current element

code/ColladaParser.h

@@ -1,42 +1,42 @@
 /*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2015, assimp team
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
+ Open Asset Import Library (assimp)
+ ----------------------------------------------------------------------
+ 
+ Copyright (c) 2006-2015, assimp team
+ All rights reserved.
+ 
+ Redistribution and use of this software in source and binary forms,
+ with or without modification, are permitted provided that the
+ following conditions are met:
+ 
+ * Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+ 
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+ 
+ * Neither the name of the assimp team, nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of the assimp team.
+ 
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ ----------------------------------------------------------------------
+ */
 
 /** @file ColladaParser.h
  *  @brief Defines the parser helper class for the collada loader
@@ -52,301 +52,302 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace Assimp
 {
-
-// ------------------------------------------------------------------------------------------
-/** Parser helper class for the Collada loader.
- *
- *  Does all the XML reading and builds internal data structures from it,
- *  but leaves the resolving of all the references to the loader.
-*/
-class ColladaParser
-{
-    friend class ColladaLoader;
-
-protected:
-    /** Constructor from XML file */
-    ColladaParser( IOSystem* pIOHandler, const std::string& pFile);
-
-    /** Destructor */
-    ~ColladaParser();
-
-    /** Reads the contents of the file */
-    void ReadContents();
-
-    /** Reads the structure of the file */
-    void ReadStructure();
-
-    /** Reads asset informations such as coordinate system informations and legal blah */
-    void ReadAssetInfo();
-
-    /** Reads the animation library */
-    void ReadAnimationLibrary();
-
-    /** Reads an animation into the given parent structure */
-    void ReadAnimation( Collada::Animation* pParent);
-
-    /** Reads an animation sampler into the given anim channel */
-    void ReadAnimationSampler( Collada::AnimationChannel& pChannel);
-
-    /** Reads the skeleton controller library */
-    void ReadControllerLibrary();
-
-    /** Reads a controller into the given mesh structure */
-    void ReadController( Collada::Controller& pController);
-
-    /** Reads the joint definitions for the given controller */
-    void ReadControllerJoints( Collada::Controller& pController);
-
-    /** Reads the joint weights for the given controller */
-    void ReadControllerWeights( Collada::Controller& pController);
-
-    /** Reads the image library contents */
-    void ReadImageLibrary();
-
-    /** Reads an image entry into the given image */
-    void ReadImage( Collada::Image& pImage);
-
-    /** Reads the material library */
-    void ReadMaterialLibrary();
-
-    /** Reads a material entry into the given material */
-    void ReadMaterial( Collada::Material& pMaterial);
-
-    /** Reads the camera library */
-    void ReadCameraLibrary();
-
-    /** Reads a camera entry into the given camera */
-    void ReadCamera( Collada::Camera& pCamera);
-
-    /** Reads the light library */
-    void ReadLightLibrary();
-
-    /** Reads a light entry into the given light */
-    void ReadLight( Collada::Light& pLight);
-
-    /** Reads the effect library */
-    void ReadEffectLibrary();
-
-    /** Reads an effect entry into the given effect*/
-    void ReadEffect( Collada::Effect& pEffect);
-
-    /** Reads an COMMON effect profile */
-    void ReadEffectProfileCommon( Collada::Effect& pEffect);
-
-    /** Read sampler properties */
-    void ReadSamplerProperties( Collada::Sampler& pSampler);
-
-    /** Reads an effect entry containing a color or a texture defining that color */
-    void ReadEffectColor( aiColor4D& pColor, Collada::Sampler& pSampler);
-
-    /** Reads an effect entry containing a float */
-    void ReadEffectFloat( float& pFloat);
-
-    /** Reads an effect parameter specification of any kind */
-    void ReadEffectParam( Collada::EffectParam& pParam);
-
-    /** Reads the geometry library contents */
-    void ReadGeometryLibrary();
-
-    /** Reads a geometry from the geometry library. */
-    void ReadGeometry( Collada::Mesh* pMesh);
-
-    /** Reads a mesh from the geometry library */
-    void ReadMesh( Collada::Mesh* pMesh);
-
-    /** Reads a source element - a combination of raw data and an accessor defining
-     * things that should not be redefinable. Yes, that's another rant.
-     */
-    void ReadSource();
-
-    /** Reads a data array holding a number of elements, and stores it in the global library.
-     * Currently supported are array of floats and arrays of strings.
-     */
-    void ReadDataArray();
-
-    /** Reads an accessor and stores it in the global library under the given ID -
-     * accessors use the ID of the parent <source> element
+    
+    // ------------------------------------------------------------------------------------------
+    /** Parser helper class for the Collada loader.
+     *
+     *  Does all the XML reading and builds internal data structures from it,
+     *  but leaves the resolving of all the references to the loader.
      */
-    void ReadAccessor( const std::string& pID);
-
-    /** Reads input declarations of per-vertex mesh data into the given mesh */
-    void ReadVertexData( Collada::Mesh* pMesh);
-
-    /** Reads input declarations of per-index mesh data into the given mesh */
-    void ReadIndexData( Collada::Mesh* pMesh);
-
-    /** Reads a single input channel element and stores it in the given array, if valid */
-    void ReadInputChannel( std::vector<Collada::InputChannel>& poChannels);
-
-    /** Reads a <p> primitive index list and assembles the mesh data into the given mesh */
-    size_t ReadPrimitives( Collada::Mesh* pMesh, std::vector<Collada::InputChannel>& pPerIndexChannels,
-        size_t pNumPrimitives, const std::vector<size_t>& pVCount, Collada::PrimitiveType pPrimType);
-
-    /** Copies the data for a single primitive into the mesh, based on the InputChannels */
-    void CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset,
-        Collada::Mesh* pMesh, std::vector<Collada::InputChannel>& pPerIndexChannels,
-        size_t currentPrimitive, const std::vector<size_t>& indices);
-
-    /** Reads one triangle of a tristrip into the mesh */
-    void ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Collada::Mesh* pMesh,
-        std::vector<Collada::InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices);
-
-    /** Extracts a single object from an input channel and stores it in the appropriate mesh data array */
-    void ExtractDataObjectFromChannel( const Collada::InputChannel& pInput, size_t pLocalIndex, Collada::Mesh* pMesh);
-
-    /** Reads the library of node hierarchies and scene parts */
-    void ReadSceneLibrary();
-
-    /** Reads a scene node's contents including children and stores it in the given node */
-    void ReadSceneNode( Collada::Node* pNode);
-
-    /** Reads a node transformation entry of the given type and adds it to the given node's transformation list. */
-    void ReadNodeTransformation( Collada::Node* pNode, Collada::TransformType pType);
-
-    /** Reads a mesh reference in a node and adds it to the node's mesh list */
-    void ReadNodeGeometry( Collada::Node* pNode);
-
-    /** Reads the collada scene */
-    void ReadScene();
-
-    // Processes bind_vertex_input and bind elements
-    void ReadMaterialVertexInputBinding( Collada::SemanticMappingTable& tbl);
-
-protected:
-    /** Aborts the file reading with an exception */
-    AI_WONT_RETURN void ThrowException( const std::string& pError) const AI_WONT_RETURN_SUFFIX;
-
-    /** Skips all data until the end node of the current element */
-    void SkipElement();
-
-    /** Skips all data until the end node of the given element */
-    void SkipElement( const char* pElement);
-
-    /** Compares the current xml element name to the given string and returns true if equal */
-    bool IsElement( const char* pName) const;
-
-    /** Tests for the opening tag of the given element, throws an exception if not found */
-    void TestOpening( const char* pName);
-
-    /** Tests for the closing tag of the given element, throws an exception if not found */
-    void TestClosing( const char* pName);
-
-    /** Checks the present element for the presence of the attribute, returns its index
-        or throws an exception if not found */
-    int GetAttribute( const char* pAttr) const;
-
-    /** Returns the index of the named attribute or -1 if not found. Does not throw,
-        therefore useful for optional attributes */
-    int TestAttribute( const char* pAttr) const;
-
-    /** Reads the text contents of an element, throws an exception if not given.
-        Skips leading whitespace. */
-    const char* GetTextContent();
-
-    /** Reads the text contents of an element, returns NULL if not given.
-        Skips leading whitespace. */
-    const char* TestTextContent();
-
-    /** Reads a single bool from current text content */
-    bool ReadBoolFromTextContent();
-
-    /** Reads a single float from current text content */
-    float ReadFloatFromTextContent();
-
-    /** Calculates the resulting transformation from all the given transform steps */
-    aiMatrix4x4 CalculateResultTransform( const std::vector<Collada::Transform>& pTransforms) const;
-
-    /** Determines the input data type for the given semantic string */
-    Collada::InputType GetTypeForSemantic( const std::string& pSemantic);
-
-    /** Finds the item in the given library by its reference, throws if not found */
-    template <typename Type> const Type& ResolveLibraryReference(
-        const std::map<std::string, Type>& pLibrary, const std::string& pURL) const;
-
-protected:
-    /** Filename, for a verbose error message */
-    std::string mFileName;
-
-    /** XML reader, member for everyday use */
-    irr::io::IrrXMLReader* mReader;
-
-    /** All data arrays found in the file by ID. Might be referred to by actually
-        everyone. Collada, you are a steaming pile of indirection. */
-    typedef std::map<std::string, Collada::Data> DataLibrary;
-    DataLibrary mDataLibrary;
-
-    /** Same for accessors which define how the data in a data array is accessed. */
-    typedef std::map<std::string, Collada::Accessor> AccessorLibrary;
-    AccessorLibrary mAccessorLibrary;
-
-    /** Mesh library: mesh by ID */
-    typedef std::map<std::string, Collada::Mesh*> MeshLibrary;
-    MeshLibrary mMeshLibrary;
-
-    /** node library: root node of the hierarchy part by ID */
-    typedef std::map<std::string, Collada::Node*> NodeLibrary;
-    NodeLibrary mNodeLibrary;
-
-    /** Image library: stores texture properties by ID */
-    typedef std::map<std::string, Collada::Image> ImageLibrary;
-    ImageLibrary mImageLibrary;
-
-    /** Effect library: surface attributes by ID */
-    typedef std::map<std::string, Collada::Effect> EffectLibrary;
-    EffectLibrary mEffectLibrary;
-
-    /** Material library: surface material by ID */
-    typedef std::map<std::string, Collada::Material> MaterialLibrary;
-    MaterialLibrary mMaterialLibrary;
-
-    /** Light library: surface light by ID */
-    typedef std::map<std::string, Collada::Light> LightLibrary;
-    LightLibrary mLightLibrary;
-
-    /** Camera library: surface material by ID */
-    typedef std::map<std::string, Collada::Camera> CameraLibrary;
-    CameraLibrary mCameraLibrary;
-
-    /** Controller library: joint controllers by ID */
-    typedef std::map<std::string, Collada::Controller> ControllerLibrary;
-    ControllerLibrary mControllerLibrary;
-
-    /** Pointer to the root node. Don't delete, it just points to one of
-        the nodes in the node library. */
-    Collada::Node* mRootNode;
-
-    /** Root animation container */
-    Collada::Animation mAnims;
-
-    /** Size unit: how large compared to a meter */
-    float mUnitSize;
-
-    /** Which is the up vector */
-    enum { UP_X, UP_Y, UP_Z } mUpDirection;
-
-    /** Collada file format version */
-    Collada::FormatVersion mFormat;
-};
-
-// ------------------------------------------------------------------------------------------------
-// Check for element match
-inline bool ColladaParser::IsElement( const char* pName) const
-{
-    ai_assert( mReader->getNodeType() == irr::io::EXN_ELEMENT);
-    return ::strcmp( mReader->getNodeName(), pName) == 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Finds the item in the given library by its reference, throws if not found
-template <typename Type>
-const Type& ColladaParser::ResolveLibraryReference( const std::map<std::string, Type>& pLibrary, const std::string& pURL) const
-{
-    typename std::map<std::string, Type>::const_iterator it = pLibrary.find( pURL);
-    if( it == pLibrary.end())
-        ThrowException( boost::str( boost::format( "Unable to resolve library reference \"%s\".") % pURL));
-    return it->second;
-}
-
+    class ColladaParser
+    {
+        friend class ColladaLoader;
+        
+    protected:
+        /** Constructor from XML file */
+        ColladaParser( IOSystem* pIOHandler, const std::string& pFile);
+        
+        /** Destructor */
+        ~ColladaParser();
+        
+        /** Reads the contents of the file */
+        void ReadContents();
+        
+        /** Reads the structure of the file */
+        void ReadStructure();
+        
+        /** Reads asset informations such as coordinate system informations and legal blah */
+        void ReadAssetInfo();
+        
+        /** Reads the animation library */
+        void ReadAnimationLibrary();
+        
+        /** Reads an animation into the given parent structure */
+        void ReadAnimation( Collada::Animation* pParent);
+        
+        /** Reads an animation sampler into the given anim channel */
+        void ReadAnimationSampler( Collada::AnimationChannel& pChannel);
+        
+        /** Reads the skeleton controller library */
+        void ReadControllerLibrary();
+        
+        /** Reads a controller into the given mesh structure */
+        void ReadController( Collada::Controller& pController);
+        
+        /** Reads the joint definitions for the given controller */
+        void ReadControllerJoints( Collada::Controller& pController);
+        
+        /** Reads the joint weights for the given controller */
+        void ReadControllerWeights( Collada::Controller& pController);
+        
+        /** Reads the image library contents */
+        void ReadImageLibrary();
+        
+        /** Reads an image entry into the given image */
+        void ReadImage( Collada::Image& pImage);
+        
+        /** Reads the material library */
+        void ReadMaterialLibrary();
+        
+        /** Reads a material entry into the given material */
+        void ReadMaterial( Collada::Material& pMaterial);
+        
+        /** Reads the camera library */
+        void ReadCameraLibrary();
+        
+        /** Reads a camera entry into the given camera */
+        void ReadCamera( Collada::Camera& pCamera);
+        
+        /** Reads the light library */
+        void ReadLightLibrary();
+        
+        /** Reads a light entry into the given light */
+        void ReadLight( Collada::Light& pLight);
+        
+        /** Reads the effect library */
+        void ReadEffectLibrary();
+        
+        /** Reads an effect entry into the given effect*/
+        void ReadEffect( Collada::Effect& pEffect);
+        
+        /** Reads an COMMON effect profile */
+        void ReadEffectProfileCommon( Collada::Effect& pEffect);
+        
+        /** Read sampler properties */
+        void ReadSamplerProperties( Collada::Sampler& pSampler);
+        
+        /** Reads an effect entry containing a color or a texture defining that color */
+        void ReadEffectColor( aiColor4D& pColor, Collada::Sampler& pSampler);
+        
+        /** Reads an effect entry containing a float */
+        void ReadEffectFloat( float& pFloat);
+        
+        /** Reads an effect parameter specification of any kind */
+        void ReadEffectParam( Collada::EffectParam& pParam);
+        
+        /** Reads the geometry library contents */
+        void ReadGeometryLibrary();
+        
+        /** Reads a geometry from the geometry library. */
+        void ReadGeometry( Collada::Mesh* pMesh);
+        
+        /** Reads a mesh from the geometry library */
+        void ReadMesh( Collada::Mesh* pMesh);
+        
+        /** Reads a source element - a combination of raw data and an accessor defining
+         * things that should not be redefinable. Yes, that's another rant.
+         */
+        void ReadSource();
+        
+        /** Reads a data array holding a number of elements, and stores it in the global library.
+         * Currently supported are array of floats and arrays of strings.
+         */
+        void ReadDataArray();
+        
+        /** Reads an accessor and stores it in the global library under the given ID -
+         * accessors use the ID of the parent <source> element
+         */
+        void ReadAccessor( const std::string& pID);
+        
+        /** Reads input declarations of per-vertex mesh data into the given mesh */
+        void ReadVertexData( Collada::Mesh* pMesh);
+        
+        /** Reads input declarations of per-index mesh data into the given mesh */
+        void ReadIndexData( Collada::Mesh* pMesh);
+        
+        /** Reads a single input channel element and stores it in the given array, if valid */
+        void ReadInputChannel( std::vector<Collada::InputChannel>& poChannels);
+        
+        /** Reads a <p> primitive index list and assembles the mesh data into the given mesh */
+        size_t ReadPrimitives( Collada::Mesh* pMesh, std::vector<Collada::InputChannel>& pPerIndexChannels,
+                              size_t pNumPrimitives, const std::vector<size_t>& pVCount, Collada::PrimitiveType pPrimType);
+        
+        /** Copies the data for a single primitive into the mesh, based on the InputChannels */
+        void CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset,
+                        Collada::Mesh* pMesh, std::vector<Collada::InputChannel>& pPerIndexChannels,
+                        size_t currentPrimitive, const std::vector<size_t>& indices);
+        
+        /** Reads one triangle of a tristrip into the mesh */
+        void ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Collada::Mesh* pMesh,
+                               std::vector<Collada::InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices);
+        
+        /** Extracts a single object from an input channel and stores it in the appropriate mesh data array */
+        void ExtractDataObjectFromChannel( const Collada::InputChannel& pInput, size_t pLocalIndex, Collada::Mesh* pMesh);
+        
+        /** Reads the library of node hierarchies and scene parts */
+        void ReadSceneLibrary();
+        
+        /** Reads a scene node's contents including children and stores it in the given node */
+        void ReadSceneNode( Collada::Node* pNode);
+        
+        /** Reads a node transformation entry of the given type and adds it to the given node's transformation list. */
+        void ReadNodeTransformation( Collada::Node* pNode, Collada::TransformType pType);
+        
+        /** Reads a mesh reference in a node and adds it to the node's mesh list */
+        void ReadNodeGeometry( Collada::Node* pNode);
+        
+        /** Reads the collada scene */
+        void ReadScene();
+        
+        // Processes bind_vertex_input and bind elements
+        void ReadMaterialVertexInputBinding( Collada::SemanticMappingTable& tbl);
+        
+    protected:
+        /** Aborts the file reading with an exception */
+        AI_WONT_RETURN void ThrowException( const std::string& pError) const AI_WONT_RETURN_SUFFIX;
+        void ReportWarning(const char* msg,...);
+
+        /** Skips all data until the end node of the current element */
+        void SkipElement();
+        
+        /** Skips all data until the end node of the given element */
+        void SkipElement( const char* pElement);
+        
+        /** Compares the current xml element name to the given string and returns true if equal */
+        bool IsElement( const char* pName) const;
+        
+        /** Tests for the opening tag of the given element, throws an exception if not found */
+        void TestOpening( const char* pName);
+        
+        /** Tests for the closing tag of the given element, throws an exception if not found */
+        void TestClosing( const char* pName);
+        
+        /** Checks the present element for the presence of the attribute, returns its index
+         or throws an exception if not found */
+        int GetAttribute( const char* pAttr) const;
+        
+        /** Returns the index of the named attribute or -1 if not found. Does not throw,
+         therefore useful for optional attributes */
+        int TestAttribute( const char* pAttr) const;
+        
+        /** Reads the text contents of an element, throws an exception if not given.
+         Skips leading whitespace. */
+        const char* GetTextContent();
+        
+        /** Reads the text contents of an element, returns NULL if not given.
+         Skips leading whitespace. */
+        const char* TestTextContent();
+        
+        /** Reads a single bool from current text content */
+        bool ReadBoolFromTextContent();
+        
+        /** Reads a single float from current text content */
+        float ReadFloatFromTextContent();
+        
+        /** Calculates the resulting transformation from all the given transform steps */
+        aiMatrix4x4 CalculateResultTransform( const std::vector<Collada::Transform>& pTransforms) const;
+        
+        /** Determines the input data type for the given semantic string */
+        Collada::InputType GetTypeForSemantic( const std::string& pSemantic);
+        
+        /** Finds the item in the given library by its reference, throws if not found */
+        template <typename Type> const Type& ResolveLibraryReference(
+                                                                     const std::map<std::string, Type>& pLibrary, const std::string& pURL) const;
+        
+    protected:
+        /** Filename, for a verbose error message */
+        std::string mFileName;
+        
+        /** XML reader, member for everyday use */
+        irr::io::IrrXMLReader* mReader;
+        
+        /** All data arrays found in the file by ID. Might be referred to by actually
+         everyone. Collada, you are a steaming pile of indirection. */
+        typedef std::map<std::string, Collada::Data> DataLibrary;
+        DataLibrary mDataLibrary;
+        
+        /** Same for accessors which define how the data in a data array is accessed. */
+        typedef std::map<std::string, Collada::Accessor> AccessorLibrary;
+        AccessorLibrary mAccessorLibrary;
+        
+        /** Mesh library: mesh by ID */
+        typedef std::map<std::string, Collada::Mesh*> MeshLibrary;
+        MeshLibrary mMeshLibrary;
+        
+        /** node library: root node of the hierarchy part by ID */
+        typedef std::map<std::string, Collada::Node*> NodeLibrary;
+        NodeLibrary mNodeLibrary;
+        
+        /** Image library: stores texture properties by ID */
+        typedef std::map<std::string, Collada::Image> ImageLibrary;
+        ImageLibrary mImageLibrary;
+        
+        /** Effect library: surface attributes by ID */
+        typedef std::map<std::string, Collada::Effect> EffectLibrary;
+        EffectLibrary mEffectLibrary;
+        
+        /** Material library: surface material by ID */
+        typedef std::map<std::string, Collada::Material> MaterialLibrary;
+        MaterialLibrary mMaterialLibrary;
+        
+        /** Light library: surface light by ID */
+        typedef std::map<std::string, Collada::Light> LightLibrary;
+        LightLibrary mLightLibrary;
+        
+        /** Camera library: surface material by ID */
+        typedef std::map<std::string, Collada::Camera> CameraLibrary;
+        CameraLibrary mCameraLibrary;
+        
+        /** Controller library: joint controllers by ID */
+        typedef std::map<std::string, Collada::Controller> ControllerLibrary;
+        ControllerLibrary mControllerLibrary;
+        
+        /** Pointer to the root node. Don't delete, it just points to one of
+         the nodes in the node library. */
+        Collada::Node* mRootNode;
+        
+        /** Root animation container */
+        Collada::Animation mAnims;
+        
+        /** Size unit: how large compared to a meter */
+        float mUnitSize;
+        
+        /** Which is the up vector */
+        enum { UP_X, UP_Y, UP_Z } mUpDirection;
+        
+        /** Collada file format version */
+        Collada::FormatVersion mFormat;
+    };
+    
+    // ------------------------------------------------------------------------------------------------
+    // Check for element match
+    inline bool ColladaParser::IsElement( const char* pName) const
+    {
+        ai_assert( mReader->getNodeType() == irr::io::EXN_ELEMENT);
+        return ::strcmp( mReader->getNodeName(), pName) == 0;
+    }
+    
+    // ------------------------------------------------------------------------------------------------
+    // Finds the item in the given library by its reference, throws if not found
+    template <typename Type>
+    const Type& ColladaParser::ResolveLibraryReference( const std::map<std::string, Type>& pLibrary, const std::string& pURL) const
+    {
+        typename std::map<std::string, Type>::const_iterator it = pLibrary.find( pURL);
+        if( it == pLibrary.end())
+            ThrowException( boost::str( boost::format( "Unable to resolve library reference \"%s\".") % pURL));
+        return it->second;
+    }
+    
 } // end of namespace Assimp
 
 #endif // AI_COLLADAPARSER_H_INC

contrib/irrXML/irrXML.cpp

@@ -1,151 +1,151 @@
-// Copyright (C) 2002-2005 Nikolaus Gebhardt
-// This file is part of the "Irrlicht Engine" and the "irrXML" project.
-// For conditions of distribution and use, see copyright notice in irrlicht.h and/or irrXML.h
-
-// Need to include Assimp, too. We're using Assimp's version of fast_atof
-// so we need stdint.h. But no PCH.
-
-
-#include "irrXML.h"
-#include "irrString.h"
-#include "irrArray.h"
-#include "./../../code/fast_atof.h"
-#include "CXMLReaderImpl.h"
-
-namespace irr
-{
-namespace io
-{
-
-//! Implementation of the file read callback for ordinary files
-class CFileReadCallBack : public IFileReadCallBack
-{
-public:
-
-	//! construct from filename
-	CFileReadCallBack(const char* filename)
-		: File(0), Size(0), Close(true)
-	{
-		// open file
-		File = fopen(filename, "rb");
-
-		if (File)
-			getFileSize();
-	}
-
-	//! construct from FILE pointer
-	CFileReadCallBack(FILE* file)
-		: File(file), Size(0), Close(false)
-	{
-		if (File)
-			getFileSize();
-	}
-
-	//! destructor
-	virtual ~CFileReadCallBack()
-	{
-		if (Close && File)
-			fclose(File);
-	}
-
-	//! Reads an amount of bytes from the file.
-	virtual int read(void* buffer, int sizeToRead)
-	{
-		if (!File)
-			return 0;
-
-		return (int)fread(buffer, 1, sizeToRead, File);
-	}
-
-	//! Returns size of file in bytes
-	virtual int getSize()
-	{
-		return Size;
-	}
-
-private:
-
-	//! retrieves the file size of the open file
-	void getFileSize()
-	{
-		fseek(File, 0, SEEK_END);
-		Size = ftell(File);
-		fseek(File, 0, SEEK_SET);
-	}
-
-	FILE* File;
-	int Size;
-	bool Close;
-
-}; // end class CFileReadCallBack
-
-
-
-// FACTORY FUNCTIONS:
-
-
-//! Creates an instance of an UFT-8 or ASCII character xml parser. 
-IrrXMLReader* createIrrXMLReader(const char* filename)
-{
-	return new CXMLReaderImpl<char, IXMLBase>(new CFileReadCallBack(filename)); 
-}
-
-
-//! Creates an instance of an UFT-8 or ASCII character xml parser. 
-IrrXMLReader* createIrrXMLReader(FILE* file)
-{
-	return new CXMLReaderImpl<char, IXMLBase>(new CFileReadCallBack(file)); 
-}
-
-
-//! Creates an instance of an UFT-8 or ASCII character xml parser. 
-IrrXMLReader* createIrrXMLReader(IFileReadCallBack* callback)
-{
-	return new CXMLReaderImpl<char, IXMLBase>(callback, false); 
-}
-
-
-//! Creates an instance of an UTF-16 xml parser. 
-IrrXMLReaderUTF16* createIrrXMLReaderUTF16(const char* filename)
-{
-	return new CXMLReaderImpl<char16, IXMLBase>(new CFileReadCallBack(filename)); 
-}
-
-
-//! Creates an instance of an UTF-16 xml parser. 
-IrrXMLReaderUTF16* createIrrXMLReaderUTF16(FILE* file)
-{
-	return new CXMLReaderImpl<char16, IXMLBase>(new CFileReadCallBack(file)); 
-}
-
-
-//! Creates an instance of an UTF-16 xml parser. 
-IrrXMLReaderUTF16* createIrrXMLReaderUTF16(IFileReadCallBack* callback)
-{
-	return new CXMLReaderImpl<char16, IXMLBase>(callback, false); 
-}
-
-
-//! Creates an instance of an UTF-32 xml parser. 
-IrrXMLReaderUTF32* createIrrXMLReaderUTF32(const char* filename)
-{
-	return new CXMLReaderImpl<char32, IXMLBase>(new CFileReadCallBack(filename)); 
-}
-
-
-//! Creates an instance of an UTF-32 xml parser. 
-IrrXMLReaderUTF32* createIrrXMLReaderUTF32(FILE* file)
-{
-	return new CXMLReaderImpl<char32, IXMLBase>(new CFileReadCallBack(file)); 
-}
-
-
-//! Creates an instance of an UTF-32 xml parser. 
-IrrXMLReaderUTF32* createIrrXMLReaderUTF32(IFileReadCallBack* callback)
-{
-	return new CXMLReaderImpl<char32, IXMLBase>(callback, false); 
-}
-
-
-} // end namespace io
-} // end namespace irr
+// Copyright (C) 2002-2005 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine" and the "irrXML" project.
+// For conditions of distribution and use, see copyright notice in irrlicht.h and/or irrXML.h
+
+// Need to include Assimp, too. We're using Assimp's version of fast_atof
+// so we need stdint.h. But no PCH.
+
+
+#include "irrXML.h"
+#include "irrString.h"
+#include "irrArray.h"
+#include "./../../code/fast_atof.h"
+#include "CXMLReaderImpl.h"
+
+namespace irr
+{
+namespace io
+{
+
+//! Implementation of the file read callback for ordinary files
+class CFileReadCallBack : public IFileReadCallBack
+{
+public:
+
+	//! construct from filename
+	CFileReadCallBack(const char* filename)
+		: File(0), Size(0), Close(true)
+	{
+		// open file
+		File = fopen(filename, "rb");
+
+		if (File)
+			getFileSize();
+	}
+
+	//! construct from FILE pointer
+	CFileReadCallBack(FILE* file)
+		: File(file), Size(0), Close(false)
+	{
+		if (File)
+			getFileSize();
+	}
+
+	//! destructor
+	virtual ~CFileReadCallBack()
+	{
+		if (Close && File)
+			fclose(File);
+	}
+
+	//! Reads an amount of bytes from the file.
+	virtual int read(void* buffer, int sizeToRead)
+	{
+		if (!File)
+			return 0;
+
+		return (int)fread(buffer, 1, sizeToRead, File);
+	}
+
+	//! Returns size of file in bytes
+	virtual int getSize()
+	{
+		return Size;
+	}
+
+private:
+
+	//! retrieves the file size of the open file
+	void getFileSize()
+	{
+		fseek(File, 0, SEEK_END);
+		Size = ftell(File);
+		fseek(File, 0, SEEK_SET);
+	}
+
+	FILE* File;
+	int Size;
+	bool Close;
+
+}; // end class CFileReadCallBack
+
+
+
+// FACTORY FUNCTIONS:
+
+
+//! Creates an instance of an UFT-8 or ASCII character xml parser. 
+IrrXMLReader* createIrrXMLReader(const char* filename)
+{
+	return new CXMLReaderImpl<char, IXMLBase>(new CFileReadCallBack(filename)); 
+}
+
+
+//! Creates an instance of an UFT-8 or ASCII character xml parser. 
+IrrXMLReader* createIrrXMLReader(FILE* file)
+{
+	return new CXMLReaderImpl<char, IXMLBase>(new CFileReadCallBack(file)); 
+}
+
+
+//! Creates an instance of an UFT-8 or ASCII character xml parser. 
+IrrXMLReader* createIrrXMLReader(IFileReadCallBack* callback)
+{
+	return new CXMLReaderImpl<char, IXMLBase>(callback, false); 
+}
+
+
+//! Creates an instance of an UTF-16 xml parser. 
+IrrXMLReaderUTF16* createIrrXMLReaderUTF16(const char* filename)
+{
+	return new CXMLReaderImpl<char16, IXMLBase>(new CFileReadCallBack(filename)); 
+}
+
+
+//! Creates an instance of an UTF-16 xml parser. 
+IrrXMLReaderUTF16* createIrrXMLReaderUTF16(FILE* file)
+{
+	return new CXMLReaderImpl<char16, IXMLBase>(new CFileReadCallBack(file)); 
+}
+
+
+//! Creates an instance of an UTF-16 xml parser. 
+IrrXMLReaderUTF16* createIrrXMLReaderUTF16(IFileReadCallBack* callback)
+{
+	return new CXMLReaderImpl<char16, IXMLBase>(callback, false); 
+}
+
+
+//! Creates an instance of an UTF-32 xml parser. 
+IrrXMLReaderUTF32* createIrrXMLReaderUTF32(const char* filename)
+{
+	return new CXMLReaderImpl<char32, IXMLBase>(new CFileReadCallBack(filename)); 
+}
+
+
+//! Creates an instance of an UTF-32 xml parser. 
+IrrXMLReaderUTF32* createIrrXMLReaderUTF32(FILE* file)
+{
+	return new CXMLReaderImpl<char32, IXMLBase>(new CFileReadCallBack(file)); 
+}
+
+
+//! Creates an instance of an UTF-32 xml parser. 
+IrrXMLReaderUTF32* createIrrXMLReaderUTF32(IFileReadCallBack* callback)
+{
+	return new CXMLReaderImpl<char32, IXMLBase>(callback, false); 
+}
+
+
+} // end namespace io
+} // end namespace irr

doc/dox.h

@@ -1,1705 +1,1705 @@
-/** @file dox.h
- *  @brief General documentation built from a doxygen comment
- */
-
-/**
-@mainpage assimp - Open Asset Import Library
-
-<img src="dragonsplash.png"></img>
-
-@section intro Introduction
-
-assimp is a library to load and process geometric scenes from various data formats. It is tailored at typical game
-scenarios by supporting a node hierarchy, static or skinned meshes, materials, bone animations and potential texture data.
-The library is *not* designed for speed, it is primarily useful for importing assets from various sources once and
-storing it in a engine-specific format for easy and fast every-day-loading. assimp is also able to apply various post
-processing steps to the imported data such as conversion to indexed meshes, calculation of normals or tangents/bitangents
-or conversion from right-handed to left-handed coordinate systems.
-
-assimp currently supports the following file formats (note that some loaders lack some features of their formats because
-some file formats contain data not supported by assimp, some stuff would require so much conversion work
-that it has not been implemented yet and some (most ...) formats lack proper specifications):
-<hr>
-<br><tt>
-<b>Collada</b> ( <i>*.dae;*.xml</i> )<br>
-<b>Blender</b> ( <i>*.blend</i> ) <sup>3</sup><br>
-<b>Biovision BVH </b> ( <i>*.bvh</i> ) <br>
-<b>3D Studio Max 3DS</b> ( <i>*.3ds</i> ) <br>
-<b>3D Studio Max ASE</b> ( <i>*.ase</i> ) <br>
-<b>Wavefront Object</b> ( <i>*.obj</i> ) <br>
-<b>Stanford Polygon Library</b> ( <i>*.ply</i> ) <br>
-<b>AutoCAD DXF</b> ( <i>*.dxf</i> ) <br>
-<b>IFC-STEP</b> ( <i>*.ifc</i> )<br>
-<b>Neutral File Format</b> ( <i>*.nff</i> ) <br>
-<b>Sense8 WorldToolkit</b> ( <i>*.nff</i> ) <br>
-<b>Valve Model</b> ( <i>*.smd,*.vta</i> ) <sup>3</sup> <br>
-<b>Quake I</b> ( <i>*.mdl</i> ) <br>
-<b>Quake II</b> ( <i>*.md2</i> ) <br>
-<b>Quake III</b> ( <i>*.md3</i> ) <br>
-<b>Quake 3 BSP</b> ( <i>*.pk3</i> )  <sup>1</sup> <br>
-<b>RtCW</b> ( <i>*.mdc</i> )<br>
-<b>Doom 3</b> ( <i>*.md5mesh;*.md5anim;*.md5camera</i> ) <br>
-<b>DirectX X </b> ( <i>*.x</i> ). <br>
-<b>Quick3D </b> ( <i>*.q3o;*q3s</i> ). <br>
-<b>Raw Triangles </b> ( <i>*.raw</i> ). <br>
-<b>AC3D </b> ( <i>*.ac</i> ). <br>
-<b>Stereolithography </b> ( <i>*.stl</i> ). <br>
-<b>Autodesk DXF </b> ( <i>*.dxf</i> ). <br>
-<b>Irrlicht Mesh </b> ( <i>*.irrmesh;*.xml</i> ). <br>
-<b>Irrlicht Scene </b> ( <i>*.irr;*.xml</i> ). <br>
-<b>Object File Format </b> ( <i>*.off</i> ). <br>
-<b>Terragen Terrain </b> ( <i>*.ter</i> ) <br>
-<b>3D GameStudio Model </b> ( <i>*.mdl</i> ) <br>
-<b>3D GameStudio Terrain</b> ( <i>*.hmp</i> )<br>
-<b>Ogre</b> (<i>*.mesh.xml, *.skeleton.xml, *.material</i>)<sup>3</sup> <br>
-<b>Milkshape 3D</b> ( <i>*.ms3d</i> )<br>
-<b>LightWave Model</b> ( <i>*.lwo</i> )<br>
-<b>LightWave Scene</b> ( <i>*.lws</i> )<br>
-<b>Modo Model</b> ( <i>*.lxo</i> )<br>
-<b>CharacterStudio Motion</b> ( <i>*.csm</i> )<br>
-<b>Stanford Ply</b> ( <i>*.ply</i> )<br>
-<b>TrueSpace</b> ( <i>*.cob, *.scn</i> )<sup>2</sup><br><br>
-</tt>
-See the @link importer_notes Importer Notes Page @endlink for informations, what a specific importer can do and what not.
-Note that although this paper claims to be the official documentation,
-http://assimp.sourceforge.net/main_features_formats.html
-<br>is usually the most up-to-date list of file formats supported by the library. <br>
-
-<sup>1</sup>: Experimental loaders<br>
-<sup>2</sup>: Indicates very limited support - many of the format's features don't map to Assimp's data structures.<br>
-<sup>3</sup>: These formats support animations, but assimp doesn't yet support them (or they're buggy)<br>
-<br>
-<hr>
-
-assimp is independent of the Operating System by nature, providing a C++ interface for easy integration
-with game engines and a C interface to allow bindings to other programming languages. At the moment the library runs
-on any little-endian platform including X86/Windows/Linux/Mac and X64/Windows/Linux/Mac. Special attention
-was paid to keep the library as free as possible from dependencies.
-
-Big endian systems such as PPC-Macs or PPC-Linux systems are not officially supported at the moment. However, most
-formats handle the required endian conversion correctly, so large parts of the library should work.
-
-The assimp linker library and viewer application are provided under the BSD 3-clause license. This basically means
-that you are free to use it in open- or closed-source projects, for commercial or non-commercial purposes as you like
-as long as you retain the license informations and take own responsibility for what you do with it. For details see
-the LICENSE file.
-
-You can find test models for almost all formats in the <assimp_root>/test/models directory. Beware, they're *free*,
-but not all of them are *open-source*. If there's an accompagning '<file>\source.txt' file don't forget to read it.
-
-@section main_install Installation
-
-assimp can be used in two ways: linking against the pre-built libraries or building the library on your own. The former
-option is the easiest, but the assimp distribution contains pre-built libraries only for Visual C++ 2005 and 2008. For other
-compilers you'll have to build assimp for yourself. Which is hopefully as hassle-free as the other way, but needs a bit
-more work. Both ways are described at the @link install Installation page. @endlink
-
-@section main_usage Usage
-
-When you're done integrating the library into your IDE / project, you can now start using it. There are two separate
-interfaces by which you can access the library: a C++ interface and a C interface using flat functions. While the former
-is easier to handle, the latter also forms a point where other programming languages can connect to. Upto the moment, though,
-there are no bindings for any other language provided. Have a look at the @link usage Usage page @endlink for a detailed explanation and code examples.
-
-@section main_data Data Structures
-
-When the importer successfully completed its job, the imported data is returned in an aiScene structure. This is the root
-point from where you can access all the various data types that a scene/model file can possibly contain. The
-@link data Data Structures page @endlink describes how to interpret this data.
-
-@section ext Extending the library
-
-There are many 3d file formats in the world, and we're happy to support as many as possible. If you need support for
-a particular file format, why not implement it yourself and add it to the library? Writing importer plugins for
-assimp is considerably easy, as the whole postprocessing infrastructure is available and does much of the work for you.
-See the @link extend Extending the library @endlink page for more information.
-
-
-
-@section main_support Support & Feedback
-
-If you have any questions/comments/suggestions/bug reports you're welcome to post them in our
-<a href="https://sourceforge.net/forum/forum.php?forum_id=817653">forums</a>. Alternatively there's
-a mailing list, <a href="https://sourceforge.net/mailarchive/forum.php?forum_name=assimp-discussions">
-assimp-discussions</a>.
-
-
-*/
-
-
-/**
-@page install Installation
-
-
-@section install_prebuilt Using the pre-built libraries with Visual C++ 8/9
-
-If you develop at Visual Studio 2005 or 2008, you can simply use the pre-built linker libraries provided in the distribution.
-Extract all files to a place of your choice. A directory called "assimp" will be created there. Add the assimp/include path
-to your include paths (Menu-&gt;Extras-&gt;Options-&gt;Projects and Solutions-&gt;VC++ Directories-&gt;Include files)
-and the assimp/lib/&lt;Compiler&gt; path to your linker paths (Menu-&gt;Extras-&gt;Options-&gt;Projects and Solutions-&gt;VC++ Directories-&gt;Library files).
-This is neccessary only once to setup all paths inside you IDE.
-
-To use the library in your C++ project you have to include either &lt;assimp/Importer.hpp&gt; or &lt;assimp/cimport.h&gt; plus some others starting with &lt;types.h&gt;.
-If you set up your IDE correctly the compiler should be able to find the files. Then you have to add the linker library to your
-project dependencies. Link to <assimp_root>/lib/<config-name>/assimp.lib. config-name is one of the predefined
-project configs. For static linking, use release/debug. See the sections below on this page for more information on the
-other build configs.
-If done correctly you should now be able to compile, link,
-run and use the application. If the linker complains about some integral functions being defined twice you propably have
-mixed the runtimes. Recheck the project configuration (project properties -&gt; C++ -&gt; Code generation -&gt; Runtime) if you use
-static runtimes (Multithreaded / Multithreaded Debug) or dynamic runtimes (Multithreaded DLL / Multithreaded Debug DLL).
-Choose the assimp linker lib accordingly.
-<br><br>
-Please don't forget to also read the @ref assimp_stl section on MSVC and the STL.
-
-@section assimp_stl Microsoft Compilers and the C++ Standard Library
-
-In VC8 and VC9 Microsoft introduced some Standard Library debugging features. A good example are improved iterator checks and
-various useful debug checks. The problem is the performance penalty that incurs with those extra checks.
-
-Most of these security enhancements are active in release builds by default, rendering assimp several times
-slower. However, it is possible to disable them by setting
-
-@code
-_HAS_ITERATOR_DEBUGGING=0
-_SECURE_SCL=0
-@endcode
-
-in the preprocessor options (or alternatively in the source code, just before the STL is included for the first time).
-<b>assimp's vc8 and vc9 configs enable these flags by default</b>.
-
-<i>If you're linking statically against assimp:</i> Make sure your applications uses the same STl settings!
-If you do not, there are two binary incompatible STL versions mangled together and you'll crash.
-Alternatively you can disable the fast STL settings for assimp by removing the 'FastSTL' property sheet from
-the vc project file.
-
-<i>If you're using assimp in a DLL/SO:</i> It's ok. There's no STL used in the binary DLL/SO interface, so it doesn't care whether
-your application uses the same STL settings or not.
-<br><br>
-Another option is to build against a different STL implementation, for example STlport. There's a special
-@ref assimp_stlport section that has a description how to achieve this.
-
-
-@section install_own Building the library from scratch
-
-To build the library on your own you first have to get hold of the dependencies. Fortunately, special attention was paid to
-keep the list of dependencies short. Unfortunately, the only dependency is <a href="http://www.boost.org">boost</a> which
-can be a bit painful to set up for certain development environments. Boost is a widely used collection of classes and
-functions for various purposes. Chances are that it was already installed along with your compiler. If not, you have to install
-it for yourself. Read the "Getting Started" section of the Boost documentation for how to setup boost. VisualStudio users
-can use a comfortable installer from <a href="http://www.boost-consulting.com/products/free">
-http://www.boost-consulting.com/products/free</a>. Choose the appropriate version of boost for your runtime of choice.
-
-<b>If you don't want to use boost</b>, you can build against our <i>"Boost-Workaround"</i>. It consists of very small
-implementations of the various boost utility classes used. However, you'll lose functionality (e.g. threading) by doing this.
-So, if you can use boost, you should use boost. Otherwise, See the @link use_noboost NoBoost-Section @endlink
-later on this page for the details of the workaround.
-
-Once boost is working, you have to set up a project for the assimp library in your favorite IDE. If you use VC2005 or
-VC2008, you can simply load the solution or project files in the workspaces/ folder, otherwise you have to create a new
-package and add all the headers and source files from the include/ and code/ directories. Set the temporary output folder
-to obj/, for example, and redirect the output folder to bin/. Then build the library - it should compile and link fine.
-
-The last step is to integrate the library into your project. This is basically the same task as described in the
-"Using the pre-built libraries" section above: add the include/ and bin/ directories to your IDE's paths so that the compiler can find
-the library files. Alternatively you can simply add the assimp project to your project's overall solution and build it inside
-your solution.
-
-
-@section use_noboost Building without boost.
-
-The Boost-Workaround consists of dummy replacements for some boost utility templates. Currently there are replacements for
-
- - boost.scoped_ptr
- - boost.scoped_array
- - boost.format
- - boost.random
- - boost.common_factor
- - boost.foreach
- - boost.tuple
- - boost.make_shared
-
-These implementations are very limited and are not intended for use outside assimp. A compiler
-with full support for partial template specializations is required. To enable the workaround, put the following in
-your compiler's list of predefined macros:
-@code
-#define ASSIMP_BUILD_BOOST_WORKAROUND
-@endcode
-<br>
-If you're working with the provided solutions for Visual Studio use the <i>-noboost</i> build configs. <br>
-
-<b>assimp_BUILD_BOOST_WORKAROUND</b> implies <b>assimp_BUILD_SINGLETHREADED</b>. <br>
-See the @ref assimp_st section
-for more details.
-
-
-
-
-@section assimp_dll Windows DLL Build
-
-assimp can be built as DLL. You just need to select a -dll config from the list of project
-configs and you're fine.
-
-<b>NOTE:</b> Theoretically, assimp-dll can be used with multithreaded (non-dll) runtime libraries,
-as long as you don't utilize any non-public stuff from the code folder. However, if you happen
-to encounter *very* strange problems, try changing the runtime to <i>Multithreaded (Debug) DLL</i>.
-
-@section assimp_stlport Building against STLport
-
-STLport is a free, fast and secure STL replacement that works with
-all major compilers and platforms. To get it, download the latest release from
-<a href="http://www.stlport.org"/><stlport.org></a>.
-Usually you'll just need to run 'configure' + a makefile (see their README for more details).
-Don't miss to add <stlport_root>/stlport to your compiler's default include paths - <b>prior</b>
-to the directory where your compiler vendor's headers lie. Do the same for  <stlport_root>/lib and
-recompile assimp. To ensure you're really building against STLport see aiGetCompileFlags().
-<br>
-In our testing, STLport builds tend to be a bit faster than builds against Microsoft's
-C++ Standard Library.
-
-*/
-
-
-/**
-@page usage Usage
-
-@section access_cpp Access by C++ class interface
-
-The assimp library can be accessed by both a class or flat function interface. The C++ class
-interface is the preferred way of interaction: you create an instance of class Assimp::Importer,
-maybe adjust some settings of it and then call Assimp::Importer::ReadFile(). The class will
-read the files and process its data, handing back the imported data as a pointer to an aiScene
-to you. You can now extract the data you need from the file. The importer manages all the resources
-for itsself. If the importer is destroyed, all the data that was created/read by it will be
-destroyed, too. So the easiest way to use the Importer is to create an instance locally, use its
-results and then simply let it go out of scope.
-
-C++ example:
-@code
-#include <assimp/Importer.hpp>      // C++ importer interface
-#include <assimp/scene.h>           // Output data structure
-#include <assimp/postprocess.h>     // Post processing flags
-
-bool DoTheImportThing( const std::string& pFile)
-{
-  // Create an instance of the Importer class
-  Assimp::Importer importer;
-
-  // And have it read the given file with some example postprocessing
-  // Usually - if speed is not the most important aspect for you - you'll
-  // propably to request more postprocessing than we do in this example.
-  const aiScene* scene = importer.ReadFile( pFile,
-	aiProcess_CalcTangentSpace       |
-	aiProcess_Triangulate            |
-	aiProcess_JoinIdenticalVertices  |
-	aiProcess_SortByPType);
-
-  // If the import failed, report it
-  if( !scene)
-  {
-    DoTheErrorLogging( importer.GetErrorString());
-    return false;
-  }
-
-  // Now we can access the file's contents.
-  DoTheSceneProcessing( scene);
-
-  // We're done. Everything will be cleaned up by the importer destructor
-  return true;
-}
-@endcode
-
-What exactly is read from the files and how you interpret it is described at the @ref data page. @endlink The post processing steps that the assimp library can apply to the
-imported data are listed at #aiPostProcessSteps. See the @ref pp Post proccessing page for more details.
-
-Note that the aiScene data structure returned is declared 'const'. Yes, you can get rid of
-these 5 letters with a simple cast. Yes, you may do that. No, it's not recommended (and it's
-suicide in DLL builds if you try to use new or delete on any of the arrays in the scene).
-
-@section access_c Access by plain-c function interface
-
-The plain function interface is just as simple, but requires you to manually call the clean-up
-after you're done with the imported data. To start the import process, call aiImportFile()
-with the filename in question and the desired postprocessing flags like above. If the call
-is successful, an aiScene pointer with the imported data is handed back to you. When you're
-done with the extraction of the data you're interested in, call aiReleaseImport() on the
-imported scene to clean up all resources associated with the import.
-
-C example:
-@code
-#include <assimp/cimport.h>        // Plain-C interface
-#include <assimp/scene.h>          // Output data structure
-#include <assimp/postprocess.h>    // Post processing flags
-
-bool DoTheImportThing( const char* pFile)
-{
-  // Start the import on the given file with some example postprocessing
-  // Usually - if speed is not the most important aspect for you - you'll t
-  // probably to request more postprocessing than we do in this example.
-  const aiScene* scene = aiImportFile( pFile,
-    aiProcess_CalcTangentSpace       |
-	aiProcess_Triangulate            |
-	aiProcess_JoinIdenticalVertices  |
-	aiProcess_SortByPType);
-
-  // If the import failed, report it
-  if( !scene)
-  {
-    DoTheErrorLogging( aiGetErrorString());
-    return false;
-  }
-
-  // Now we can access the file's contents
-  DoTheSceneProcessing( scene);
-
-  // We're done. Release all resources associated with this import
-  aiReleaseImport( scene);
-  return true;
-}
-@endcode
-
-@section custom_io Using custom IO logic with the C++ class interface
-
-The assimp library needs to access files internally. This of course applies to the file you want
-to read, but also to additional files in the same folder for certain file formats. By default,
-standard C/C++ IO logic is used to access these files. If your application works in a special
-environment where custom logic is needed to access the specified files, you have to supply
-custom implementations of IOStream and IOSystem. A shortened example might look like this:
-
-@code
-#include <assimp/IOStream.hpp>
-#include <assimp/IOSystem.hpp>
-
-// My own implementation of IOStream
-class MyIOStream : public Assimp::IOStream
-{
-  friend class MyIOSystem;
-
-protected:
-  // Constructor protected for private usage by MyIOSystem
-  MyIOStream(void);
-
-public:
-  ~MyIOStream(void);
-  size_t Read( void* pvBuffer, size_t pSize, size_t pCount) { ... }
-  size_t Write( const void* pvBuffer, size_t pSize, size_t pCount) { ... }
-  aiReturn Seek( size_t pOffset, aiOrigin pOrigin) { ... }
-  size_t Tell() const { ... }
-  size_t FileSize() const { ... }
-  void Flush () { ... }
-};
-
-// Fisher Price - My First Filesystem
-class MyIOSystem : public Assimp::IOSystem
-{
-  MyIOSystem() { ... }
-  ~MyIOSystem() { ... }
-
-  // Check whether a specific file exists
-  bool Exists( const std::string& pFile) const {
-    ..
-  }
-
-  // Get the path delimiter character we'd like to see
-  char GetOsSeparator() const {
-    return '/';
-  }
-
-  // ... and finally a method to open a custom stream
-  IOStream* Open( const std::string& pFile, const std::string& pMode) {
-	return new MyIOStream( ... );
-  }
-
-  void Close( IOStream* pFile) { delete pFile; }
-};
-@endcode
-
-Now that your IO system is implemented, supply an instance of it to the Importer object by calling
-Assimp::Importer::SetIOHandler().
-
-@code
-void DoTheImportThing( const std::string& pFile)
-{
-  Assimp::Importer importer;
-  // put my custom IO handling in place
-  importer.SetIOHandler( new MyIOSystem());
-
-  // the import process will now use this implementation to access any file
-  importer.ReadFile( pFile, SomeFlag | SomeOtherFlag);
-}
-@endcode
-
-
-@section custom_io_c Using custom IO logic with the plain-c function interface
-
-The C interface also provides a way to override the file system. Control is not as fine-grained as for C++ although
-surely enough for almost any purpose. The process is simple:
-
-<ul>
-<li> Include cfileio.h
-<li> Fill an aiFileIO structure with custom file system callbacks (they're self-explanatory as they work similar to the CRT's fXXX functions)
-<li> .. and pass it as parameter to #aiImportFileEx
-</ul>
-
-@section  logging Logging
-
-The assimp library provides an easy mechanism to log messages. For instance if you want to check the state of your
-import and you just want to see, after which preprocessing step the import-process was aborted you can take a look
-into the log.
-Per default the assimp-library provides a default log implementation, where you can log your user specific message
-by calling it as a singleton with the requested logging-type. To see how this works take a look to this:
-
-@code
-using namespace Assimp;
-
-// Create a logger instance
-DefaultLogger::create("",Logger::VERBOSE);
-
-// Now I am ready for logging my stuff
-DefaultLogger::get()->info("this is my info-call");
-
-// Kill it after the work is done
-DefaultLogger::kill();
-@endcode
-
-At first you have to create the default-logger-instance (create). Now you are ready to rock and can log a
-little bit around. After that you should kill it to release the singleton instance.
-
-If you want to integrate the assimp-log into your own GUI it my be helpful to have a mechanism writing
-the logs into your own log windows. The logger interface provides this by implementing an interface called LogStream.
-You can attach and detach this log stream to the default-logger instance or any implementation derived from Logger.
-Just derivate your own logger from the abstract base class LogStream and overwrite the write-method:
-
-@code
-// Example stream
-class myStream :
-	public LogStream
-{
-public:
-	// Constructor
-	myStream()
-	{
-		// empty
-	}
-
-	// Destructor
-	~myStream()
-	{
-		// empty
-	}
-
-	// Write womethink using your own functionality
-	void write(const char* message)
-	{
-		::printf("%s\n", message);
-	}
-};
-
-// Select the kinds of messages you want to receive on this log stream
-const unsigned int severity = Logger::DEBUGGING|Logger::INFO|Logger::ERR|Logger::WARN;
-
-// Attaching it to the default logger
-Assimp::DefaultLogger::get()->attachStream( new myStream(), severity );
-
-@endcode
-
-The severity level controls the kind of message which will be written into
-the attached stream. If you just want to log errors and warnings set the warn
-and error severity flag for those severities. It is also possible to remove
-a self defined logstream from an error severity by detaching it with the severity
-flag set:
-
-@code
-
-unsigned int severity = 0;
-severity |= Logger::DEBUGGING;
-
-// Detach debug messages from you self defined stream
-Assimp::DefaultLogger::get()->attachStream( new myStream(), severity );
-
-@endcode
-
-If you want to implement your own logger just derive from the abstract base class
-#Logger and overwrite the methods debug, info, warn and error.
-
-If you want to see the debug-messages in a debug-configured build, the Logger-interface
-provides a logging-severity. You can set it calling the following method:
-
-@code
-
-Assimp::DefaultLogger::get()->setLogSeverity( LogSeverity log_severity );
-
-@endcode
-
-The normal logging severity supports just the basic stuff like, info, warnings and errors.
-In the verbose level very fine-grained debug messages will be logged, too. Note that this
-kind kind of logging might decrease import performance.
-*/
-
-/**
-@page data Data Structures
-
-The assimp library returns the imported data in a collection of structures. aiScene forms the root
-of the data, from here you gain access to all the nodes, meshes, materials, animations or textures
-that were read from the imported file. The aiScene is returned from a successful call to
-assimp::Importer::ReadFile(), aiImportFile() or aiImportFileEx() - see the @link usage Usage page @endlink
-for further information on how to use the library.
-
-By default, all 3D data is provided in a right-handed coordinate system such as OpenGL uses. In
-this coordinate system, +X points to the right, -Z points away from the viewer into the screen and
-+Y points upwards. Several modeling packages such as 3D Studio Max use this coordinate system as well (or a rotated variant of it).
-By contrast, some other environments use left-handed coordinate systems, a prominent example being
-DirectX. If you need the imported data to be in a left-handed coordinate system, supply the
-#aiProcess_MakeLeftHanded flag to the ReadFile() function call.
-
-The output face winding is counter clockwise. Use #aiProcess_FlipWindingOrder to get CW data.
-@code
-x2
-
-            x1
-	x0
-@endcode
-
-Outputted polygons can be literally everything: they're probably concave, self-intersecting or non-planar,
-although our built-in triangulation (#aiProcess_Triangulate postprocessing step) doesn't handle the two latter.
-
-The output UV coordinate system has its origin in the lower-left corner:
-@code
-0y|1y ---------- 1x|1y
- |                |
- |                |
- |                |
-0x|0y ---------- 1x|0y
-@endcode
-Use the #aiProcess_FlipUVs flag to get UV coordinates with the upper-left corner als origin.
-
-All matrices in the library are row-major. That means that the matrices are stored row by row in memory,
-which is similar to the OpenGL matrix layout. A typical 4x4 matrix including a translational part looks like this:
-@code
-X1  Y1  Z1  T1
-X2  Y2  Z2  T2
-X3  Y3  Z3  T3
-0   0   0   1
-@endcode
-
-... with (X1, X2, X3) being the X base vector, (Y1, Y2, Y3) being the Y base vector, (Z1, Z2, Z3)
-being the Z base vector and (T1, T2, T3) being the translation part. If you want to use these matrices
-in DirectX functions, you have to transpose them.
-
-<hr>
-
-<b>11.24.09:</b> We changed the orientation of our quaternions to the most common convention to avoid confusion.
-However, if you're a previous user of Assimp and you update the library to revisions beyond SVNREV 502,
-you have to adapt your animation loading code to match the new quaternion orientation.
-
-<hr>
-
-@section hierarchy The Node Hierarchy
-
-Nodes are little named entities in the scene that have a place and orientation relative to their parents.
-Starting from the scene's root node all nodes can have 0 to x child nodes, thus forming a hierarchy.
-They form the base on which the scene is built on: a node can refer to 0..x meshes, can be referred to
-by a bone of a mesh or can be animated by a key sequence of an animation. DirectX calls them "frames",
-others call them "objects", we call them aiNode.
-
-A node can potentially refer to single or multiple meshes. The meshes are not stored inside the node, but
-instead in an array of aiMesh inside the aiScene. A node only refers to them by their array index. This also means
-that multiple nodes can refer to the same mesh, which provides a simple form of instancing. A mesh referred to
-by this way lives in the node's local coordinate system. If you want the mesh's orientation in global
-space, you'd have to concatenate the transformations from the referring node and all of its parents.
-
-Most of the file formats don't really support complex scenes, though, but a single model only. But there are
-more complex formats such as .3ds, .x or .collada scenes which may contain an arbitrary complex
-hierarchy of nodes and meshes. I for myself would suggest a recursive filter function such as the
-following pseudocode:
-
-@code
-void CopyNodesWithMeshes( aiNode node, SceneObject targetParent, Matrix4x4 accTransform)
-{
-  SceneObject parent;
-  Matrix4x4 transform;
-
-  // if node has meshes, create a new scene object for it
-  if( node.mNumMeshes > 0)
-  {
-    SceneObjekt newObject = new SceneObject;
-    targetParent.addChild( newObject);
-    // copy the meshes
-    CopyMeshes( node, newObject);
-
-    // the new object is the parent for all child nodes
-    parent = newObject;
-    transform.SetUnity();
-  } else
-  {
-    // if no meshes, skip the node, but keep its transformation
-    parent = targetParent;
-    transform = node.mTransformation * accTransform;
-  }
-
-  // continue for all child nodes
-  for( all node.mChildren)
-    CopyNodesWithMeshes( node.mChildren[a], parent, transform);
-}
-@endcode
-
-This function copies a node into the scene graph if it has children. If yes, a new scene object
-is created for the import node and the node's meshes are copied over. If not, no object is created.
-Potential child objects will be added to the old targetParent, but there transformation will be correct
-in respect to the global space. This function also works great in filtering the bone nodes - nodes
-that form the bone hierarchy for another mesh/node, but don't have any mesh themselves.
-
-@section meshes Meshes
-
-All meshes of an imported scene are stored in an array of aiMesh* inside the aiScene. Nodes refer
-to them by their index in the array and providing the coordinate system for them, too. One mesh uses
-only a single material everywhere - if parts of the model use a different material, this part is
-moved to a separate mesh at the same node. The mesh refers to its material in the same way as the
-node refers to its meshes: materials are stored in an array inside aiScene, the mesh stores only
-an index into this array.
-
-An aiMesh is defined by a series of data channels. The presence of these data channels is defined
-by the contents of the imported file: by default there are only those data channels present in the mesh
-that were also found in the file. The only channels guarenteed to be always present are aiMesh::mVertices
-and aiMesh::mFaces. You can test for the presence of other data by testing the pointers against NULL
-or use the helper functions provided by aiMesh. You may also specify several post processing flags
-at Importer::ReadFile() to let assimp calculate or recalculate additional data channels for you.
-
-At the moment, a single aiMesh may contain a set of triangles and polygons. A single vertex does always
-have a position. In addition it may have one normal, one tangent and bitangent, zero to AI_MAX_NUMBER_OF_TEXTURECOORDS
-(4 at the moment) texture coords and zero to AI_MAX_NUMBER_OF_COLOR_SETS (4) vertex colors. In addition
-a mesh may or may not have a set of bones described by an array of aiBone structures. How to interpret
-the bone information is described later on.
-
-@section material Materials
-
-See the @link materials Material System Page. @endlink
-
-@section bones Bones
-
-A mesh may have a set of bones in the form of aiBone structures.. Bones are a means to deform a mesh
-according to the movement of a skeleton. Each bone has a name and a set of vertices on which it has influence.
-Its offset matrix declares the transformation needed to transform from mesh space to the local space of this bone.
-
-Using the bones name you can find the corresponding node in the node hierarchy. This node in relation
-to the other bones' nodes defines the skeleton of the mesh. Unfortunately there might also be
-nodes which are not used by a bone in the mesh, but still affect the pose of the skeleton because
-they have child nodes which are bones. So when creating the skeleton hierarchy for a mesh I
-suggest the following method:
-
-a) Create a map or a similar container to store which nodes are necessary for the skeleton.
-Pre-initialise it for all nodes with a "no". <br>
-b) For each bone in the mesh: <br>
-b1) Find the corresponding node in the scene's hierarchy by comparing their names. <br>
-b2) Mark this node as "yes" in the necessityMap. <br>
-b3) Mark all of its parents the same way until you 1) find the mesh's node or 2) the parent of the mesh's node. <br>
-c) Recursively iterate over the node hierarchy <br>
-c1) If the node is marked as necessary, copy it into the skeleton and check its children <br>
-c2) If the node is marked as not necessary, skip it and do not iterate over its children. <br>
-
-Reasons: you need all the parent nodes to keep the transformation chain intact. For most
-file formats and modelling packages the node hierarchy of the skeleton is either a child
-of the mesh node or a sibling of the mesh node but this is by no means a requirement so you shouldn't rely on it.
-The node closest to the root node is your skeleton root, from there you
-start copying the hierarchy. You can skip every branch without a node being a bone in the mesh -
-that's why the algorithm skips the whole branch if the node is marked as "not necessary".
-
-You should now have a mesh in your engine with a skeleton that is a subset of the imported hierarchy.
-
-@section anims Animations
-
-An imported scene may contain zero to x aiAnimation entries. An animation in this context is a set
-of keyframe sequences where each sequence describes the orientation of a single node in the hierarchy
-over a limited time span. Animations of this kind are usually used to animate the skeleton of
-a skinned mesh, but there are other uses as well.
-
-An aiAnimation has a duration. The duration as well as all time stamps are given in ticks. To get
-the correct timing, all time stamp thus have to be divided by aiAnimation::mTicksPerSecond. Beware,
-though, that certain combinations of file format and exporter don't always store this information
-in the exported file. In this case, mTicksPerSecond is set to 0 to indicate the lack of knowledge.
-
-The aiAnimation consists of a series of aiNodeAnim's. Each bone animation affects a single node in
-the node hierarchy only, the name specifying which node is affected. For this node the structure
-stores three separate key sequences: a vector key sequence for the position, a quaternion key sequence
-for the rotation and another vector key sequence for the scaling. All 3d data is local to the
-coordinate space of the node's parent, that means in the same space as the node's transformation matrix.
-There might be cases where animation tracks refer to a non-existent node by their name, but this
-should not be the case in your every-day data.
-
-To apply such an animation you need to identify the animation tracks that refer to actual bones
-in your mesh. Then for every track: <br>
-a) Find the keys that lay right before the current anim time. <br>
-b) Optional: interpolate between these and the following keys. <br>
-c) Combine the calculated position, rotation and scaling to a tranformation matrix <br>
-d) Set the affected node's transformation to the calculated matrix. <br>
-
-If you need hints on how to convert to or from quaternions, have a look at the
-<a href="http://www.j3d.org/matrix_faq/matrfaq_latest.html">Matrix&Quaternion FAQ</a>. I suggest
-using logarithmic interpolation for the scaling keys if you happen to need them - usually you don't
-need them at all.
-
-@section textures Textures
-
-Normally textures used by assets are stored in separate files, however,
-there are file formats embedding their textures directly into the model file.
-Such textures are loaded into an aiTexture structure.
-<br>
-There are two cases:
-<br>
-<b>1)</b> The texture is NOT compressed. Its color data is directly stored
-in the aiTexture structure as an array of aiTexture::mWidth * aiTexture::mHeight aiTexel structures. Each aiTexel represents a pixel (or "texel") of the texture
-image. The color data is stored in an unsigned RGBA8888 format, which can be easily used for
-both Direct3D and OpenGL (swizzling the order of the color components might be necessary).
-RGBA8888 has been chosen because it is well-known, easy to use and natively
-supported by nearly all graphics APIs.
-<br>
-<b>2)</b> This applies if aiTexture::mHeight == 0 is fullfilled. Then, texture is stored in a
-"compressed" format such as DDS or PNG. The term "compressed" does not mean that the
-texture data must actually be compressed, however the texture was found in the
-model file as if it was stored in a separate file on the harddisk. Appropriate
-decoders (such as libjpeg, libpng, D3DX, DevIL) are required to load theses textures.
-aiTexture::mWidth specifies the size of the texture data in bytes, aiTexture::pcData is
-a pointer to the raw image data and aiTexture::achFormatHint is either zeroed or
-contains the most common file extension of the embedded texture's format. This value is only
-set if assimp is able to determine the file format.
-*/
-
-
-/**
-@page materials Material System
-
-@section General Overview
-All materials are stored in an array of aiMaterial inside the aiScene.
-
-Each aiMesh refers to one
-material by its index in the array. Due to the vastly diverging definitions and usages of material
-parameters there is no hard definition of a material structure. Instead a material is defined by
-a set of properties accessible by their names. Have a look at assimp/material.h to see what types of
-properties are defined. In this file there are also various functions defined to test for the
-presence of certain properties in a material and retrieve their values.
-
-@section mat_tex Textures
-
-Textures are organized in stacks, each stack being evaluated independently. The final color value from a particular texture stack is used in the shading equation. For example, the computed color value of the diffuse texture stack (aiTextureType_DIFFUSE) is multipled with the amount of incoming diffuse light to obtain the final diffuse color of a pixel.
-
-@code
-
- Stack                               Resulting equation
-
-------------------------
-| Constant base color  |             color
-------------------------
-| Blend operation 0    |             +
-------------------------
-| Strength factor 0    |             0.25*
-------------------------
-| Texture 0            |             texture_0
-------------------------
-| Blend operation 1    |             *
-------------------------
-| Strength factor 1    |             1.0*
-------------------------
-| Texture 1            |             texture_1
-------------------------
-  ...                                ...
-
-@endcode
-
-@section keys Constants
-
-All material key constants start with 'AI_MATKEY' (it's an ugly macro for historical reasons, don't ask).
-
-<table border="1">
-  <tr>
-    <th>Name</th>
-    <th>Data Type</th>
-    <th>Default Value</th>
-	<th>Meaning</th>
-	<th>Notes</th>
-  </tr>
-  <tr>
-    <td><tt>NAME</tt></td>
-    <td>aiString</td>
-    <td>n/a</td>
-	<td>The name of the material, if available. </td>
-	<td>Ignored by <tt>aiProcess_RemoveRedundantMaterials</tt>. Materials are considered equal even if their names are different.</td>
-  </tr>
-  <tr>
-    <td><tt>COLOR_DIFFUSE</tt></td>
-    <td>aiColor3D</td>
-    <td>black (0,0,0)</td>
-	<td>Diffuse color of the material. This is typically scaled by the amount of incoming diffuse light (e.g. using gouraud shading) </td>
-	<td>---</td>
-  </tr>
-  <tr>
-    <td><tt>COLOR_SPECULAR</tt></td>
-    <td>aiColor3D</td>
-    <td>black (0,0,0)</td>
-	<td>Specular color of the material. This is typically scaled by the amount of incoming specular light (e.g. using phong shading) </td>
-	<td>---</td>
-  </tr>
-  <tr>
-    <td><tt>COLOR_AMBIENT</tt></td>
-    <td>aiColor3D</td>
-    <td>black (0,0,0)</td>
-	<td>Ambient color of the material. This is typically scaled by the amount of ambient light </td>
-	<td>---</td>
-  </tr>
-  <tr>
-    <td><tt>COLOR_EMISSIVE</tt></td>
-    <td>aiColor3D</td>
-    <td>black (0,0,0)</td>
-	<td>Emissive color of the material. This is the amount of light emitted by the object. In real time applications it will usually not affect surrounding objects, but raytracing applications may wish to treat emissive objects as light sources. </td>
-	<td>---</tt></td>
-  </tr>
-
-  <tr>
-    <td><tt>COLOR_TRANSPARENT</tt></td>
-    <td>aiColor3D</td>
-    <td>black (0,0,0)</td>
-	<td>Defines the transparent color of the material, this is the color to be multiplied with the color of
-	translucent light to construct the final 'destination color' for a particular position in the screen buffer. T </td>
-	<td>---</tt></td>
-  </tr>
-
-  <tr>
-    <td><tt>WIREFRAME</tt></td>
-    <td>int</td>
-    <td>false</td>
-	<td>Specifies whether wireframe rendering must be turned on for the material. 0 for false, !0 for true. </td>
-	<td>---</tt></td>
-  </tr>
-
-  <tr>
-    <td><tt>TWOSIDED</tt></td>
-    <td>int</td>
-    <td>false</td>
-	<td>Specifies whether meshes using this material must be rendered without backface culling. 0 for false, !0 for true. </td>
-	<td>Some importers set this property if they don't know whether the output face oder is right. As long as it is not set, you may safely enable backface culling.</tt></td>
-  </tr>
-
-  <tr>
-    <td><tt>SHADING_MODEL</tt></td>
-    <td>int</td>
-    <td>gouraud</td>
-	<td>One of the #aiShadingMode enumerated values. Defines the library shading model to use for (real time) rendering to approximate the original look of the material as closely as possible. </td>
-	<td>The presence of this key might indicate a more complex material. If absent, assume phong shading only if a specular exponent is given.</tt></td>
-  </tr>
-
-  <tr>
-    <td><tt>BLEND_FUNC</tt></td>
-    <td>int</td>
-    <td>false</td>
-	<td>One of the #aiBlendMode enumerated values. Defines how the final color value in the screen buffer is computed from the given color at that position and the newly computed color from the material. Simply said, alpha blending settings.</td>
-	<td>-</td>
-  </tr>
-
-  <tr>
-    <td><tt>OPACITY</tt></td>
-    <td>float</td>
-    <td>1.0</td>
-	<td>Defines the opacity of the material in a range between 0..1.</td>
-	<td>Use this value to decide whether you have to activate alpha blending for rendering. <tt>OPACITY</tt> != 1 usually also implies TWOSIDED=1 to avoid cull artifacts.</td>
-  </tr>
-
-  <tr>
-    <td><tt>SHININESS</tt></td>
-    <td>float</td>
-    <td>0.f</td>
-	<td>Defines the shininess of a phong-shaded material. This is actually the exponent of the phong specular equation</td>
-	<td><tt>SHININESS</tt>=0 is equivalent to <tt>SHADING_MODEL</tt>=<tt>aiShadingMode_Gouraud</tt>.</td>
-  </tr>
-
-  <tr>
-    <td><tt>SHININESS_STRENGTH</tt></td>
-    <td>float</td>
-    <td>1.0</td>
-	<td>Scales the specular color of the material.</td>
-	<td>This value is kept separate from the specular color by most modelers, and so do we.</td>
-  </tr>
-
-  <tr>
-    <td><tt>REFRACTI</tt></td>
-    <td>float</td>
-    <td>1.0</td>
-	<td>Defines the Index Of Refraction for the material. That's not supported by most file formats.</td>
-	<td>Might be of interest for raytracing.</td>
-  </tr>
-
-  <tr>
-    <td><tt>TEXTURE(t,n)</tt></td>
-    <td>aiString</td>
-    <td>n/a</td>
-	<td>Defines the path to the n'th texture on the stack 't', where 'n' is any value >= 0 and 't' is one of the #aiTextureType enumerated values.</td>
-	<td>See the 'Textures' section above.</td>
-  </tr>
-
-  <tr>
-    <td><tt>TEXBLEND(t,n)</tt></td>
-    <td>float</td>
-    <td>n/a</td>
-	<td>Defines the strength the n'th texture on the stack 't'. All color components (rgb) are multipled with this factor *before* any further processing is done.</td>
-	<td>-</td>
-  </tr>
-
-  <tr>
-    <td><tt>TEXOP(t,n)</tt></td>
-    <td>int</td>
-    <td>n/a</td>
-	<td>One of the #aiTextureOp enumerated values. Defines the arithmetic operation to be used to combine the n'th texture on the stack 't' with the n-1'th. <tt>TEXOP(t,0)</tt> refers to the blend operation between the base color for this stack (e.g. <tt>COLOR_DIFFUSE</tt> for the diffuse stack) and the first texture.</td>
-	<td>-</td>
-  </tr>
-
-  <tr>
-    <td><tt>MAPPING(t,n)</tt></td>
-    <td>int</td>
-    <td>n/a</td>
-	<td>Defines how the input mapping coordinates for sampling the n'th texture on the stack 't' are computed. Usually explicit UV coordinates are provided, but some model file formats might also be using basic shapes, such as spheres or cylinders, to project textures onto meshes.</td>
-	<td>See the 'Textures' section below. #aiProcess_GenUVCoords can be used to let Assimp compute proper UV coordinates from projective mappings.</td>
-  </tr>
-
-  <tr>
-    <td><tt>UVWSRC(t,n)</tt></td>
-    <td>int</td>
-    <td>n/a</td>
-	<td>Defines the UV channel to be used as input mapping coordinates for sampling the n'th texture on the stack 't'. All meshes assigned to this material share the same UV channel setup</td>
-	<td>Presence of this key implies <tt>MAPPING(t,n)</tt> to be #aiTextureMapping_UV. See @ref uvwsrc for more details. </td>
-  </tr>
-
-  <tr>
-    <td><tt>MAPPINGMODE_U(t,n)</tt></td>
-    <td>int</td>
-    <td>n/a</td>
-	<td>Any of the #aiTextureMapMode enumerated values. Defines the texture wrapping mode on the x axis for sampling the n'th texture on the stack 't'. 'Wrapping' occurs whenever UVs lie outside the 0..1 range. </td>
-	<td>-</td>
-  </tr>
-
-  <tr>
-    <td><tt>MAPPINGMODE_V(t,n)</tt></td>
-    <td>int</td>
-    <td>n/a</td>
-	<td>Wrap mode on the v axis. See <tt>MAPPINGMODE_U</tt>. </td>
-	<td>-</td>
-  </tr>
-
-   <tr>
-    <td><tt>TEXMAP_AXIS(t,n)</tt></td>
-    <td>aiVector3D</td>
-    <td>n/a</td>
-	<td></tt> Defines the base axis to to compute the mapping coordinates for the n'th texture on the stack 't' from. This is not required for UV-mapped textures. For instance, if <tt>MAPPING(t,n)</tt> is #aiTextureMapping_SPHERE, U and V would map to longitude and latitude of a sphere around the given axis. The axis is given in local mesh space.</td>
-	<td>-</td>
-  </tr>
-
-  <tr>
-    <td><tt>TEXFLAGS(t,n)</tt></td>
-    <td>int</td>
-    <td>n/a</td>
-	<td></tt> Defines miscellaneous flag for the n'th texture on the stack 't'. This is a bitwise combination of the #aiTextureFlags enumerated values.</td>
-	<td>-</td>
-  </tr>
-
-</table>
-
-@section cpp C++-API
-
-Retrieving a property from a material is done using various utility functions. For C++ it's simply calling aiMaterial::Get()
-
-@code
-
-aiMaterial* mat = .....
-
-// The generic way
-if(AI_SUCCESS != mat->Get(<material-key>,<where-to-store>)) {
-   // handle epic failure here
-}
-
-@endcode
-
-Simple, isn't it? To get the name of a material you would use
-
-@code
-
-aiString name;
-mat->Get(AI_MATKEY_NAME,name);
-
-@endcode
-
-Or for the diffuse color ('color' won't be modified if the property is not set)
-
-@code
-
-aiColor3D color (0.f,0.f,0.f);
-mat->Get(AI_MATKEY_COLOR_DIFFUSE,color);
-
-@endcode
-
-<b>Note:</b> Get() is actually a template with explicit specializations for aiColor3D, aiColor4D, aiString, float, int and some others.
-Make sure that the type of the second parameter matches the expected data type of the material property (no compile-time check yet!).
-Don't follow this advice if you wish to encounter very strange results.
-
-@section C C-API
-
-For good old C it's slightly different. Take a look at the aiGetMaterialGet<data-type> functions.
-
-@code
-
-aiMaterial* mat = .....
-
-if(AI_SUCCESS != aiGetMaterialFloat(mat,<material-key>,<where-to-store>)) {
-   // handle epic failure here
-}
-
-@endcode
-
-To get the name of a material you would use
-
-@code
-
-aiString name;
-aiGetMaterialString(mat,AI_MATKEY_NAME,&name);
-
-@endcode
-
-Or for the diffuse color ('color' won't be modified if the property is not set)
-
-@code
-
-aiColor3D color (0.f,0.f,0.f);
-aiGetMaterialColor(mat,AI_MATKEY_COLOR_DIFFUSE,&color);
-
-@endcode
-
-@section uvwsrc How to map UV channels to textures (MATKEY_UVWSRC)
-
-The MATKEY_UVWSRC property is only present if the source format doesn't specify an explicit mapping from
-textures to UV channels. Many formats don't do this and assimp is not aware of a perfect rule either.
-
-Your handling of UV channels needs to be flexible therefore. Our recommendation is to use logic like this
-to handle most cases properly:
-
-@verbatim
-have only one uv channel?
-   assign channel 0 to all textures and break
-
-for all textures
-   have uvwsrc for this texture?
-      assign channel specified in uvwsrc
-   else
-      assign channels in ascending order for all texture stacks,
-	    i.e. diffuse1 gets channel 1, opacity0 gets channel 0.
-
-@endverbatim
-
-@section pseudo Pseudo Code Listing
-
-For completeness, the following is a very rough pseudo-code sample showing how to evaluate Assimp materials in your
-shading pipeline. You'll probably want to limit your handling of all those material keys to a reasonable subset suitable for your purposes
-(for example most 3d engines won't support highly complex multi-layer materials, but many 3d modellers do).
-
-Also note that this sample is targeted at a (shader-based) rendering pipeline for real time graphics.
-
-@code
-
-// ---------------------------------------------------------------------------------------
-// Evaluate multiple textures stacked on top of each other
-float3 EvaluateStack(stack)
-{
-  // For the 'diffuse' stack stack.base_color would be COLOR_DIFFUSE
-  // and TEXTURE(aiTextureType_DIFFUSE,n) the n'th texture.
-
-  float3 base = stack.base_color;
-  for (every texture in stack)
-  {
-    // assuming we have explicit & pretransformed UVs for this texture
-    float3 color = SampleTexture(texture,uv);
-
-    // scale by texture blend factor
-    color *= texture.blend;
-
-    if (texture.op == add)
-      base += color;
-    else if (texture.op == multiply)
-      base *= color;
-    else // other blend ops go here
-  }
-  return base;
-}
-
-// ---------------------------------------------------------------------------------------
-// Compute the diffuse contribution for a pixel
-float3 ComputeDiffuseContribution()
-{
-  if (shading == none)
-     return float3(1,1,1);
-
-  float3 intensity (0,0,0);
-  for (all lights in range)
-  {
-    float fac = 1.f;
-    if (shading == gouraud)
-      fac =  lambert-term ..
-    else // other shading modes go here
-
-    // handling of different types of lights, such as point or spot lights
-    // ...
-
-    // and finally sum the contribution of this single light ...
-    intensity += light.diffuse_color * fac;
-  }
-  // ... and combine the final incoming light with the diffuse color
-  return EvaluateStack(diffuse) * intensity;
-}
-
-// ---------------------------------------------------------------------------------------
-// Compute the specular contribution for a pixel
-float3 ComputeSpecularContribution()
-{
-  if (shading == gouraud || specular_strength == 0 || specular_exponent == 0)
-    return float3(0,0,0);
-
-  float3 intensity (0,0,0);
-  for (all lights in range)
-  {
-    float fac = 1.f;
-    if (shading == phong)
-      fac =  phong-term ..
-    else // other specular shading modes go here
-
-    // handling of different types of lights, such as point or spot lights
-    // ...
-
-    // and finally sum the specular contribution of this single light ...
-    intensity += light.specular_color * fac;
-  }
-  // ... and combine the final specular light with the specular color
-  return EvaluateStack(specular) * intensity * specular_strength;
-}
-
-// ---------------------------------------------------------------------------------------
-// Compute the ambient contribution for a pixel
-float3 ComputeAmbientContribution()
-{
-  if (shading == none)
-     return float3(0,0,0);
-
-  float3 intensity (0,0,0);
-  for (all lights in range)
-  {
-    float fac = 1.f;
-
-    // handling of different types of lights, such as point or spot lights
-    // ...
-
-    // and finally sum the ambient contribution of this single light ...
-    intensity += light.ambient_color * fac;
-  }
-  // ... and combine the final ambient light with the ambient color
-  return EvaluateStack(ambient) * intensity;
-}
-
-// ---------------------------------------------------------------------------------------
-// Compute the final color value for a pixel
-// @param prev Previous color at that position in the framebuffer
-float4 PimpMyPixel (float4 prev)
-{
-  // .. handle displacement mapping per vertex
-  // .. handle bump/normal mapping
-
-  // Get all single light contribution terms
-  float3 diff = ComputeDiffuseContribution();
-  float3 spec = ComputeSpecularContribution();
-  float3 ambi = ComputeAmbientContribution();
-
-  // .. and compute the final color value for this pixel
-  float3 color = diff + spec + ambi;
-  float3 opac  = EvaluateStack(opacity);
-
-  // note the *slightly* strange meaning of additive and multiplicative blending here ...
-  // those names will most likely be changed in future versions
-  if (blend_func == add)
-       return prev+color*opac;
-  else if (blend_func == multiply)
-       return prev*(1.0-opac)+prev*opac;
-
-   return color;
-}
-
-@endcode
-
-*/
-
-
-
-
-/**
-@page perf Performance
-
-@section perf_overview Overview
-
-This page discusses general performance issues related to assimp.
-
-@section perf_profile Profiling
-
-assimp has built-in support for <i>very</i> basic profiling and time measurement. To turn it on, set the <tt>GLOB_MEASURE_TIME</tt>
-configuration switch to <tt>true</tt> (nonzero). Results are dumped to the log file, so you need to setup
-an appropriate logger implementation with at least one output stream first (see the @link logging Logging Page @endlink
-for the details.).
-
-Note that these measurements are based on a single run of the importer and each of the post processing steps, so
-a single result set is far away from being significant in a statistic sense. While precision can be improved
-by running the test multiple times, the low accuracy of the timings may render the results useless
-for smaller files.
-
-A sample report looks like this (some unrelated log messages omitted, entries grouped for clarity):
-
-@verbatim
-Debug, T5488: START `total`
-Info,  T5488: Found a matching importer for this file format
-
-
-Debug, T5488: START `import`
-Info,  T5488: BlendModifier: Applied the `Subdivision` modifier to `OBMonkey`
-Debug, T5488: END   `import`, dt= 3.516 s
-
-
-Debug, T5488: START `preprocess`
-Debug, T5488: END   `preprocess`, dt= 0.001 s
-Info,  T5488: Entering post processing pipeline
-
-
-Debug, T5488: START `postprocess`
-Debug, T5488: RemoveRedundantMatsProcess begin
-Debug, T5488: RemoveRedundantMatsProcess finished
-Debug, T5488: END   `postprocess`, dt= 0.001 s
-
-
-Debug, T5488: START `postprocess`
-Debug, T5488: TriangulateProcess begin
-Info,  T5488: TriangulateProcess finished. All polygons have been triangulated.
-Debug, T5488: END   `postprocess`, dt= 3.415 s
-
-
-Debug, T5488: START `postprocess`
-Debug, T5488: SortByPTypeProcess begin
-Info,  T5488: Points: 0, Lines: 0, Triangles: 1, Polygons: 0 (Meshes, X = removed)
-Debug, T5488: SortByPTypeProcess finished
-
-Debug, T5488: START `postprocess`
-Debug, T5488: JoinVerticesProcess begin
-Debug, T5488: Mesh 0 (unnamed) | Verts in: 503808 out: 126345 | ~74.922
-Info,  T5488: JoinVerticesProcess finished | Verts in: 503808 out: 126345 | ~74.9
-Debug, T5488: END   `postprocess`, dt= 2.052 s
-
-Debug, T5488: START `postprocess`
-Debug, T5488: FlipWindingOrderProcess begin
-Debug, T5488: FlipWindingOrderProcess finished
-Debug, T5488: END   `postprocess`, dt= 0.006 s
-
-
-Debug, T5488: START `postprocess`
-Debug, T5488: LimitBoneWeightsProcess begin
-Debug, T5488: LimitBoneWeightsProcess end
-Debug, T5488: END   `postprocess`, dt= 0.001 s
-
-
-Debug, T5488: START `postprocess`
-Debug, T5488: ImproveCacheLocalityProcess begin
-Debug, T5488: Mesh 0 | ACMR in: 0.851622 out: 0.718139 | ~15.7
-Info,  T5488: Cache relevant are 1 meshes (251904 faces). Average output ACMR is 0.718139
-Debug, T5488: ImproveCacheLocalityProcess finished.
-Debug, T5488: END   `postprocess`, dt= 1.903 s
-
-
-Info,  T5488: Leaving post processing pipeline
-Debug, T5488: END   `total`, dt= 11.269 s
-@endverbatim
-
-In this particular example only one fourth of the total import time was spent on the actual importing, while the rest of the
-time got consumed by the #aiProcess_Triangulate, #aiProcess_JoinIdenticalVertices and #aiProcess_ImproveCacheLocality
-postprocessing steps. A wise selection of postprocessing steps is therefore essential to getting good performance.
-Of course this depends on the individual requirements of your application, in many of the typical use cases of assimp performance won't
-matter (i.e. in an offline content pipeline).
-*/
-
-/**
-@page threading Threading
-
-@section overview Overview
-
-This page discusses both assimps scalability in threaded environments and the precautions to be taken in order to
-use it from multiple threads concurrently.
-
-@section threadsafety Thread-safety / using Assimp concurrently from several threads
-
-The library can be accessed by multiple threads simultaneously, as long as the
-following prerequisites are fulfilled:
-
- - Users of the C++-API should ensure that they use a dedicated #Assimp::Importer instance for each thread. Constructing instances of #Assimp::Importer is expensive, so it might be a good idea to
-   let every thread maintain its own thread-local instance (which can be used to
-   load as many files as necessary).
- - The C-API is thread safe.
- - When supplying custom IO logic, one must make sure the underlying implementation is thread-safe.
- - Custom log streams or logger replacements have to be thread-safe, too.
-
-
-
-
-Multiple concurrent imports may or may not be beneficial, however. For certain file formats in conjunction with
-little or no post processing IO times tend to be the performance bottleneck. Intense post processing together
-with 'slow' file formats like X or Collada might scale well with multiple concurrent imports.
-
-
-@section automt Internal threading
-
-Internal multi-threading is not currently implemented.
-*/
-
-/**
-@page res Resources
-
-This page lists some useful resources for assimp. Note that, even though the core team has an eye on them,
-we cannot guarantee the accuracy of third-party information. If in doubt, it's best to ask either on the
-mailing list or on our forums on SF.net.
-
- - assimp comes with some sample applications, these can be found in the <i>./samples</i> folder. Don't forget to read the <i>README</i> file.
- - http://www.drivenbynostalgia.com/files/AssimpOpenGLDemo.rar - OpenGl animation sample using the library's animation import facilities.
- - http://nolimitsdesigns.com/game-design/open-asset-import-library-animation-loader/ is another utility to
-   simplify animation playback.
- - http://ogldev.atspace.co.uk/www/tutorial22/tutorial22.html - Tutorial "Loading models using the Open Asset Import Library", out of a series of OpenGl tutorials.
-
-*/
-
-
-/**
-@page importer_notes Importer Notes
-
-<hr>
-@section blender Blender
-
-This section contains implementation notes for the Blender3D importer.
-@subsection bl_overview Overview
-
-assimp provides a self-contained reimplementation of Blender's so called SDNA system (http://www.blender.org/development/architecture/notes-on-sdna/).
-SDNA allows Blender to be fully backward and forward compatible and to exchange
-files across all platforms. The BLEND format is thus a non-trivial binary monster and the loader tries to read the most of it,
-naturally limited by the scope of the #aiScene output data structure.
-Consequently, if Blender is the only modeling tool in your asset work flow, consider writing a
-custom exporter from Blender if assimps format coverage does not meet the requirements.
-
-@subsection bl_status Current status
-
-The Blender loader does not support animations yet, but is apart from that considered relatively stable.
-
-@subsection bl_notes Notes
-
-When filing bugs on the Blender loader, always give the Blender version (or, even better, post the file caused the error).
-
-<hr>
-@section ifc IFC
-
-This section contains implementation notes on the IFC-STEP importer.
-@subsection ifc_overview Overview
-
-The library provides a partial implementation of the IFC2x3 industry standard for automatized exchange of CAE/architectural
-data sets. See http://en.wikipedia.org/wiki/Industry_Foundation_Classes for more information on the format. We aim
-at getting as much 3D data out of the files as possible.
-
-@subsection ifc_status Current status
-
-IFC support is new and considered experimental. Please report any bugs you may encounter.
-
-@subsection ifc_notes Notes
-
-- Only the STEP-based encoding is supported. IFCZIP and IFCXML are not (but IFCZIP can simply be unzipped to get a STEP file).
-- The importer leaves vertex coordinates untouched, but applies a global scaling to the root transform to
-  convert from whichever unit the IFC file uses to <i>metres</i>.
-- If multiple geometric representations are provided, the choice which one to load is based on how expensive a representation seems
- to be in terms of import time. The loader also avoids representation types for which it has known deficits.
-- Not supported are arbitrary binary operations (binary clipping is implemented, though).
-- Of the various relationship types that IFC knows, only aggregation, containment and material assignment are resolved and mapped to
-  the output graph.
-- The implementation knows only about IFC2X3 and applies this rule set to all models it encounters,
-  regardless of their actual version. Loading of older or newer files may fail with parsing errors.
-
-@subsection ifc_metadata Metadata
-
-IFC file properties (IfcPropertySet) are kept as per-node metadata, see aiNode::mMetaData.
-
-<hr>
-@section ogre Ogre
-*ATTENTION*: The Ogre-Loader is currently under development, many things have changed after this documentation was written, but they are not final enough to rewrite the documentation. So things may have changed by now!
-
-This section contains implementations notes for the OgreXML importer.
-@subsection overview Overview
-Ogre importer is currently optimized for the Blender Ogre exporter, because thats the only one that I use. You can find the Blender Ogre exporter at: http://www.ogre3d.org/forums/viewtopic.php?f=8&t=45922
-
-@subsection what What will be loaded?
-
-Mesh: Faces, Positions, Normals and all TexCoords. The Materialname will be used to load the material.
-
-Material: The right material in the file will be searched, the importer should work with materials who
-have 1 technique and 1 pass in this technique. From there, the texturename (for 1 color- and 1 normalmap) and the
-materialcolors (but not in custom materials) will be loaded. Also, the materialname will be set.
-
-Skeleton: Skeleton with Bone hierarchy (Position and Rotation, but no Scaling in the skeleton is supported), names and transformations,
-animations with rotation, translation and scaling keys.
-
-@subsection export_Blender How to export Files from Blender
-You can find informations about how to use the Ogreexporter by your own, so here are just some options that you need, so the assimp
-importer will load everything correctly:
-- Use either "Rendering Material" or "Custom Material" see @ref material
-- do not use "Flip Up Axies to Y"
-- use "Skeleton name follow mesh"
-
-
-@subsection xml XML Format
-There is a binary and a XML mesh Format from Ogre. This loader can only
-Handle xml files, but don't panic, there is a command line converter, which you can use
-to create XML files from Binary Files. Just look on the Ogre page for it.
-
-Currently you can only load meshes. So you will need to import the *.mesh.xml file, the loader will
-try to find the appendant material and skeleton file.
-
-The skeleton file must have the same name as the mesh file, e.g. fish.mesh.xml and fish.skeleton.xml.
-
-@subsection material Materials
-The material file can have the same name as the mesh file (if the file is model.mesh or model.mesh.xml the
-loader will try to load model.material),
-or you can use Importer::Importer::SetPropertyString(AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE, "materiafile.material")
-to specify the name of the material file. This is especially usefull if multiply materials a stored in a single file.
-The importer will first try to load the material with the same name as the mesh and only if this can't be open try
-to load the alternate material file. The default material filename is "Scene.material".
-
-We suggest that you use custom materials, because they support multiple textures (like colormap and normalmap). First of all you
-should read the custom material sektion in the Ogre Blender exporter Help File, and than use the assimp.tlp template, which you
-can find in scripts/OgreImpoter/Assimp.tlp in the assimp source. If you don't set all values, don't worry, they will be ignored during import.
-
-If you want more properties in custom materials, you can easily expand the ogre material loader, it will be just a few lines for each property.
-Just look in OgreImporterMaterial.cpp
-
-@subsection Importer Properties
--	IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME: Normally, a texture is loaded as a colormap, if no
-	target is specified in the
-	materialfile. Is this switch is enabled, texture names ending with _n, _l, _s
-	are used as normalmaps, lightmaps or specularmaps.
-	<br>
-	Property type: Bool. Default value: false.
--	IMPORT_OGRE_MATERIAL_FILE: Ogre Meshes contain only the MaterialName, not the MaterialFile.
-	If there
-	is no material file with the same name as the material, Ogre Importer will
-	try to load this file and search the material in it.
-	<br>
-	Property type: String. Default value: guessed.
-
-@subsection todo Todo
-- Load colors in custom materials
-- extend custom and normal material loading
-- fix bone hierarchy bug
-- test everything elaboratly
-- check for non existent animation keys (what happens if a one time not all bones have a key?)
-*/
-
-
-/**
-@page extend Extending the Library
-
-@section General
-
-Or - how to write your own loaders. It's easy. You just need to implement the #Assimp::BaseImporter class,
-which defines a few abstract methods, register your loader, test it carefully and provide test models for it.
-
-OK, that sounds too easy :-). The whole procedure for a new loader merely looks like this:
-
-<ul>
-<li>Create a header (<tt><i>FormatName</i>Importer.h</tt>) and a unit (<tt><i>FormatName</i>Importer.cpp</tt>) in the <tt>&lt;root&gt;/code/</tt> directory</li>
-<li>Add them to the following workspaces: vc8 and vc9 (the files are in the workspaces directory), CMAKE (code/CMakeLists.txt, create a new
-source group for your importer and put them also to ADD_LIBRARY( assimp SHARED))</li>
-<li>Include <i>AssimpPCH.h</i> - this is the PCH file, and it includes already most Assimp-internal stuff. </li>
-<li>Open Importer.cpp and include your header just below the <i>(include_new_importers_here)</i> line,
-guarded by a #define
-@code
-#if (!defined assimp_BUILD_NO_FormatName_IMPORTER)
-	...
-#endif
-@endcode
-Wrap the same guard around your .cpp!</li>
-
-<li>Now advance to the <i>(register_new_importers_here)</i> line in the Importer.cpp and register your importer there - just like all the others do.</li>
-<li>Setup a suitable test environment (i.e. use AssimpView or your own application), make sure to enable
-the #aiProcess_ValidateDataStructure flag and enable verbose logging. That is, simply call before you import anything:
-@code
-DefaultLogger::create("AssimpLog.txt",Logger::VERBOSE)
-@endcode
-</li>
-<li>
-Implement the Assimp::BaseImporter::CanRead(), Assimp::BaseImporter::InternReadFile() and Assimp::BaseImporter::GetExtensionList().
-Just copy'n'paste the template from Appendix A and adapt it for your needs.
-</li>
-<li>For error handling, throw a dynamic allocated ImportErrorException (see Appendix A) for critical errors, and log errors, warnings, infos and debuginfos
-with DefaultLogger::get()->[error, warn, debug, info].
-</li>
-<li>
-Make sure that your loader compiles against all build configurations on all supported platforms. This includes <i>-noboost</i>! To avoid problems,
-see the boost section on this page for a list of all 'allowed' boost classes (again, this grew historically when we had to accept that boost
-is not THAT widely spread that one could rely on it being available everywhere).
-</li>
-<li>
-Provide some _free_ test models in <tt>&lt;root&gt;/test/models/&lt;FormatName&gt;/</tt> and credit their authors.
-Test files for a file format shouldn't be too large (<i>~500 KiB in total</i>), and not too repetive. Try to cover all format features with test data.
-</li>
-<li>
-Done! Please, share your loader that everyone can profit from it!
-</li>
-</ul>
-
-@section properties Properties
-
-You can use properties to chance the behavior of you importer. In order to do so, you have to overide BaseImporter::SetupProperties, and specify
-you custom properties in config.h. Just have a look to the other AI_CONFIG_IMPORT_* defines and you will understand, how it works.
-
-The properties can be set with Importer::SetProperty***() and can be accessed in your SetupProperties function with Importer::GetProperty***(). You can
-store the properties as a member variable of your importer, they are thread safe.
-
-@section tnote Notes for text importers
-
-<ul>
-<li>Try to make your parser as flexible as possible. Don't rely on particular layout, whitespace/tab style,
-except if the file format has a strict definition, in which case you should always warn about spec violations.
-But the general rule of thumb is <i>be strict in what you write and tolerant in what you accept</i>.</li>
-<li>Call Assimp::BaseImporter::ConvertToUTF8() before you parse anything to convert foreign encodings to UTF-8.
- That's not necessary for XML importers, which must use the provided IrrXML for reading. </li>
-</ul>
-
-@section bnote Notes for binary importers
-
-<ul>
-<li>
-Take care of endianess issues! Assimp importers mostly support big-endian platforms, which define the <tt>AI_BUILD_BIG_ENDIAN</tt> constant.
-See the next section for a list of utilities to simplify this task.
-</li>
-<li>
-Don't trust the input data! Check all offsets!
-</li>
-</ul>
-
-@section util Utilities
-
-Mixed stuff for internal use by loaders, mostly documented (most of them are already included by <i>AssimpPCH.h</i>):
-<ul>
-<li><b>ByteSwapper</b> (<i>ByteSwapper.h</i>) - manual byte swapping stuff for binary loaders.</li>
-<li><b>StreamReader</b> (<i>StreamReader.h</i>) - safe, endianess-correct, binary reading.</li>
-<li><b>IrrXML</b> (<i>irrXMLWrapper.h</i>)  - for XML-parsing (SAX.</li>
-<li><b>CommentRemover</b> (<i>RemoveComments.h</i>) - remove single-line and multi-line comments from a text file.</li>
-<li>fast_atof, strtoul10, strtoul16, SkipSpaceAndLineEnd, SkipToNextToken .. large family of low-level
-parsing functions, mostly declared in <i>fast_atof.h</i>, <i>StringComparison.h</i> and <i>ParsingUtils.h</i> (a collection that grew
-historically, so don't expect perfect organization). </li>
-<li><b>ComputeNormalsWithSmoothingsGroups()</b> (<i>SmoothingGroups.h</i>) - Computes normal vectors from plain old smoothing groups. </li>
-<li><b>SkeletonMeshBuilder</b> (<i>SkeletonMeshBuilder.h</i>) - generate a dummy mesh from a given (animation) skeleton. </li>
-<li><b>StandardShapes</b> (<i>StandardShapes.h</i>) - generate meshes for standard solids, such as platonic primitives, cylinders or spheres. </li>
-<li><b>BatchLoader</b> (<i>BaseImporter.h</i>) - manage imports from external files. Useful for file formats
-which spread their data across multiple files. </li>
-<li><b>SceneCombiner</b> (<i>SceneCombiner.h</i>) - exhaustive toolset to merge multiple scenes. Useful for file formats
-which spread their data across multiple files. </li>
-</ul>
-
-@section mat Filling materials
-
-The required definitions zo set/remove/query keys in #aiMaterial structures are declared in <i>MaterialSystem.h</i>, in a
-#aiMaterial derivate called #aiMaterial. The header is included by AssimpPCH.h, so you don't need to bother.
-
-@code
-aiMaterial* mat = new aiMaterial();
-
-const float spec = 16.f;
-mat->AddProperty(&spec, 1, AI_MATKEY_SHININESS);
-
-//set the name of the material:
-NewMaterial->AddProperty(&aiString(MaterialName.c_str()), AI_MATKEY_NAME);//MaterialName is a std::string
-
-//set the first diffuse texture
-NewMaterial->AddProperty(&aiString(Texturename.c_str()), AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));//again, Texturename is a std::string
-@endcode
-
-@section boost Boost
-
-The boost whitelist:
-<ul>
-<li><i>boost.scoped_ptr</i></li>
-<li><i>boost.scoped_array</i></li>
-<li><i>boost.format</i> </li>
-<li><i>boost.random</i> </li>
-<li><i>boost.common_factor</i> </li>
-<li><i>boost.foreach</i> </li>
-<li><i>boost.tuple</i></li>
-</ul>
-
-(if you happen to need something else, i.e. boost::thread, make this an optional feature.
-<tt>assimp_BUILD_BOOST_WORKAROUND</tt> is defined for <i>-noboost</i> builds)
-
-@section appa Appendix A - Template for BaseImporter's abstract methods
-
-@code
-// -------------------------------------------------------------------------------
-// Returns whether the class can handle the format of the given file.
-bool xxxxImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler,
-	bool checkSig) const
-{
-	const std::string extension = GetExtension(pFile);
-	if(extension == "xxxx") {
-		return true;
-	}
-	if (!extension.length() || checkSig) {
-		// no extension given, or we're called a second time because no
-		// suitable loader was found yet. This means, we're trying to open
-		// the file and look for and hints to identify the file format.
-		// #Assimp::BaseImporter provides some utilities:
-		//
-		// #Assimp::BaseImporter::SearchFileHeaderForToken - for text files.
-		// It reads the first lines of the file and does a substring check
-		// against a given list of 'magic' strings.
-		//
-		// #Assimp::BaseImporter::CheckMagicToken - for binary files. It goes
-		// to a particular offset in the file and and compares the next words
-		// against a given list of 'magic' tokens.
-
-		// These checks MUST be done (even if !checkSig) if the file extension
-		// is not exclusive to your format. For example, .xml is very common
-		// and (co)used by many formats.
-	}
-	return false;
-}
-
-// -------------------------------------------------------------------------------
-// Get list of file extensions handled by this loader
-void xxxxImporter::GetExtensionList(std::set<std::string>& extensions)
-{
-	extensions.insert("xxx");
-}
-
-// -------------------------------------------------------------------------------
-void xxxxImporter::InternReadFile( const std::string& pFile,
-	aiScene* pScene, IOSystem* pIOHandler)
-{
-	boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
-
-	// Check whether we can read from the file
-	if( file.get() == NULL) {
-		throw DeadlyImportError( "Failed to open xxxx file " + pFile + ".");
-	}
-
-	// Your task: fill pScene
-	// Throw a ImportErrorException with a meaningful (!) error message if
-	// something goes wrong.
-}
-
-@endcode
- */
-
-
- /**
- @page AnimationOverview Animation Overview
- \section Transformations
- This diagram shows how you can calculate your transformationmatrices for an animated character:
- <img src="AnimationOverview.png" />
-
- **/
+/** @file dox.h
+ *  @brief General documentation built from a doxygen comment
+ */
+
+/**
+@mainpage assimp - Open Asset Import Library
+
+<img src="dragonsplash.png"></img>
+
+@section intro Introduction
+
+assimp is a library to load and process geometric scenes from various data formats. It is tailored at typical game
+scenarios by supporting a node hierarchy, static or skinned meshes, materials, bone animations and potential texture data.
+The library is *not* designed for speed, it is primarily useful for importing assets from various sources once and
+storing it in a engine-specific format for easy and fast every-day-loading. assimp is also able to apply various post
+processing steps to the imported data such as conversion to indexed meshes, calculation of normals or tangents/bitangents
+or conversion from right-handed to left-handed coordinate systems.
+
+assimp currently supports the following file formats (note that some loaders lack some features of their formats because
+some file formats contain data not supported by assimp, some stuff would require so much conversion work
+that it has not been implemented yet and some (most ...) formats lack proper specifications):
+<hr>
+<br><tt>
+<b>Collada</b> ( <i>*.dae;*.xml</i> )<br>
+<b>Blender</b> ( <i>*.blend</i> ) <sup>3</sup><br>
+<b>Biovision BVH </b> ( <i>*.bvh</i> ) <br>
+<b>3D Studio Max 3DS</b> ( <i>*.3ds</i> ) <br>
+<b>3D Studio Max ASE</b> ( <i>*.ase</i> ) <br>
+<b>Wavefront Object</b> ( <i>*.obj</i> ) <br>
+<b>Stanford Polygon Library</b> ( <i>*.ply</i> ) <br>
+<b>AutoCAD DXF</b> ( <i>*.dxf</i> ) <br>
+<b>IFC-STEP</b> ( <i>*.ifc</i> )<br>
+<b>Neutral File Format</b> ( <i>*.nff</i> ) <br>
+<b>Sense8 WorldToolkit</b> ( <i>*.nff</i> ) <br>
+<b>Valve Model</b> ( <i>*.smd,*.vta</i> ) <sup>3</sup> <br>
+<b>Quake I</b> ( <i>*.mdl</i> ) <br>
+<b>Quake II</b> ( <i>*.md2</i> ) <br>
+<b>Quake III</b> ( <i>*.md3</i> ) <br>
+<b>Quake 3 BSP</b> ( <i>*.pk3</i> )  <sup>1</sup> <br>
+<b>RtCW</b> ( <i>*.mdc</i> )<br>
+<b>Doom 3</b> ( <i>*.md5mesh;*.md5anim;*.md5camera</i> ) <br>
+<b>DirectX X </b> ( <i>*.x</i> ). <br>
+<b>Quick3D </b> ( <i>*.q3o;*q3s</i> ). <br>
+<b>Raw Triangles </b> ( <i>*.raw</i> ). <br>
+<b>AC3D </b> ( <i>*.ac</i> ). <br>
+<b>Stereolithography </b> ( <i>*.stl</i> ). <br>
+<b>Autodesk DXF </b> ( <i>*.dxf</i> ). <br>
+<b>Irrlicht Mesh </b> ( <i>*.irrmesh;*.xml</i> ). <br>
+<b>Irrlicht Scene </b> ( <i>*.irr;*.xml</i> ). <br>
+<b>Object File Format </b> ( <i>*.off</i> ). <br>
+<b>Terragen Terrain </b> ( <i>*.ter</i> ) <br>
+<b>3D GameStudio Model </b> ( <i>*.mdl</i> ) <br>
+<b>3D GameStudio Terrain</b> ( <i>*.hmp</i> )<br>
+<b>Ogre</b> (<i>*.mesh.xml, *.skeleton.xml, *.material</i>)<sup>3</sup> <br>
+<b>Milkshape 3D</b> ( <i>*.ms3d</i> )<br>
+<b>LightWave Model</b> ( <i>*.lwo</i> )<br>
+<b>LightWave Scene</b> ( <i>*.lws</i> )<br>
+<b>Modo Model</b> ( <i>*.lxo</i> )<br>
+<b>CharacterStudio Motion</b> ( <i>*.csm</i> )<br>
+<b>Stanford Ply</b> ( <i>*.ply</i> )<br>
+<b>TrueSpace</b> ( <i>*.cob, *.scn</i> )<sup>2</sup><br><br>
+</tt>
+See the @link importer_notes Importer Notes Page @endlink for informations, what a specific importer can do and what not.
+Note that although this paper claims to be the official documentation,
+http://assimp.sourceforge.net/main_features_formats.html
+<br>is usually the most up-to-date list of file formats supported by the library. <br>
+
+<sup>1</sup>: Experimental loaders<br>
+<sup>2</sup>: Indicates very limited support - many of the format's features don't map to Assimp's data structures.<br>
+<sup>3</sup>: These formats support animations, but assimp doesn't yet support them (or they're buggy)<br>
+<br>
+<hr>
+
+assimp is independent of the Operating System by nature, providing a C++ interface for easy integration
+with game engines and a C interface to allow bindings to other programming languages. At the moment the library runs
+on any little-endian platform including X86/Windows/Linux/Mac and X64/Windows/Linux/Mac. Special attention
+was paid to keep the library as free as possible from dependencies.
+
+Big endian systems such as PPC-Macs or PPC-Linux systems are not officially supported at the moment. However, most
+formats handle the required endian conversion correctly, so large parts of the library should work.
+
+The assimp linker library and viewer application are provided under the BSD 3-clause license. This basically means
+that you are free to use it in open- or closed-source projects, for commercial or non-commercial purposes as you like
+as long as you retain the license informations and take own responsibility for what you do with it. For details see
+the LICENSE file.
+
+You can find test models for almost all formats in the <assimp_root>/test/models directory. Beware, they're *free*,
+but not all of them are *open-source*. If there's an accompagning '<file>\source.txt' file don't forget to read it.
+
+@section main_install Installation
+
+assimp can be used in two ways: linking against the pre-built libraries or building the library on your own. The former
+option is the easiest, but the assimp distribution contains pre-built libraries only for Visual C++ 2005 and 2008. For other
+compilers you'll have to build assimp for yourself. Which is hopefully as hassle-free as the other way, but needs a bit
+more work. Both ways are described at the @link install Installation page. @endlink
+
+@section main_usage Usage
+
+When you're done integrating the library into your IDE / project, you can now start using it. There are two separate
+interfaces by which you can access the library: a C++ interface and a C interface using flat functions. While the former
+is easier to handle, the latter also forms a point where other programming languages can connect to. Upto the moment, though,
+there are no bindings for any other language provided. Have a look at the @link usage Usage page @endlink for a detailed explanation and code examples.
+
+@section main_data Data Structures
+
+When the importer successfully completed its job, the imported data is returned in an aiScene structure. This is the root
+point from where you can access all the various data types that a scene/model file can possibly contain. The
+@link data Data Structures page @endlink describes how to interpret this data.
+
+@section ext Extending the library
+
+There are many 3d file formats in the world, and we're happy to support as many as possible. If you need support for
+a particular file format, why not implement it yourself and add it to the library? Writing importer plugins for
+assimp is considerably easy, as the whole postprocessing infrastructure is available and does much of the work for you.
+See the @link extend Extending the library @endlink page for more information.
+
+
+
+@section main_support Support & Feedback
+
+If you have any questions/comments/suggestions/bug reports you're welcome to post them in our
+<a href="https://sourceforge.net/forum/forum.php?forum_id=817653">forums</a>. Alternatively there's
+a mailing list, <a href="https://sourceforge.net/mailarchive/forum.php?forum_name=assimp-discussions">
+assimp-discussions</a>.
+
+
+*/
+
+
+/**
+@page install Installation
+
+
+@section install_prebuilt Using the pre-built libraries with Visual C++ 8/9
+
+If you develop at Visual Studio 2005 or 2008, you can simply use the pre-built linker libraries provided in the distribution.
+Extract all files to a place of your choice. A directory called "assimp" will be created there. Add the assimp/include path
+to your include paths (Menu-&gt;Extras-&gt;Options-&gt;Projects and Solutions-&gt;VC++ Directories-&gt;Include files)
+and the assimp/lib/&lt;Compiler&gt; path to your linker paths (Menu-&gt;Extras-&gt;Options-&gt;Projects and Solutions-&gt;VC++ Directories-&gt;Library files).
+This is neccessary only once to setup all paths inside you IDE.
+
+To use the library in your C++ project you have to include either &lt;assimp/Importer.hpp&gt; or &lt;assimp/cimport.h&gt; plus some others starting with &lt;types.h&gt;.
+If you set up your IDE correctly the compiler should be able to find the files. Then you have to add the linker library to your
+project dependencies. Link to <assimp_root>/lib/<config-name>/assimp.lib. config-name is one of the predefined
+project configs. For static linking, use release/debug. See the sections below on this page for more information on the
+other build configs.
+If done correctly you should now be able to compile, link,
+run and use the application. If the linker complains about some integral functions being defined twice you propably have
+mixed the runtimes. Recheck the project configuration (project properties -&gt; C++ -&gt; Code generation -&gt; Runtime) if you use
+static runtimes (Multithreaded / Multithreaded Debug) or dynamic runtimes (Multithreaded DLL / Multithreaded Debug DLL).
+Choose the assimp linker lib accordingly.
+<br><br>
+Please don't forget to also read the @ref assimp_stl section on MSVC and the STL.
+
+@section assimp_stl Microsoft Compilers and the C++ Standard Library
+
+In VC8 and VC9 Microsoft introduced some Standard Library debugging features. A good example are improved iterator checks and
+various useful debug checks. The problem is the performance penalty that incurs with those extra checks.
+
+Most of these security enhancements are active in release builds by default, rendering assimp several times
+slower. However, it is possible to disable them by setting
+
+@code
+_HAS_ITERATOR_DEBUGGING=0
+_SECURE_SCL=0
+@endcode
+
+in the preprocessor options (or alternatively in the source code, just before the STL is included for the first time).
+<b>assimp's vc8 and vc9 configs enable these flags by default</b>.
+
+<i>If you're linking statically against assimp:</i> Make sure your applications uses the same STl settings!
+If you do not, there are two binary incompatible STL versions mangled together and you'll crash.
+Alternatively you can disable the fast STL settings for assimp by removing the 'FastSTL' property sheet from
+the vc project file.
+
+<i>If you're using assimp in a DLL/SO:</i> It's ok. There's no STL used in the binary DLL/SO interface, so it doesn't care whether
+your application uses the same STL settings or not.
+<br><br>
+Another option is to build against a different STL implementation, for example STlport. There's a special
+@ref assimp_stlport section that has a description how to achieve this.
+
+
+@section install_own Building the library from scratch
+
+To build the library on your own you first have to get hold of the dependencies. Fortunately, special attention was paid to
+keep the list of dependencies short. Unfortunately, the only dependency is <a href="http://www.boost.org">boost</a> which
+can be a bit painful to set up for certain development environments. Boost is a widely used collection of classes and
+functions for various purposes. Chances are that it was already installed along with your compiler. If not, you have to install
+it for yourself. Read the "Getting Started" section of the Boost documentation for how to setup boost. VisualStudio users
+can use a comfortable installer from <a href="http://www.boost-consulting.com/products/free">
+http://www.boost-consulting.com/products/free</a>. Choose the appropriate version of boost for your runtime of choice.
+
+<b>If you don't want to use boost</b>, you can build against our <i>"Boost-Workaround"</i>. It consists of very small
+implementations of the various boost utility classes used. However, you'll lose functionality (e.g. threading) by doing this.
+So, if you can use boost, you should use boost. Otherwise, See the @link use_noboost NoBoost-Section @endlink
+later on this page for the details of the workaround.
+
+Once boost is working, you have to set up a project for the assimp library in your favorite IDE. If you use VC2005 or
+VC2008, you can simply load the solution or project files in the workspaces/ folder, otherwise you have to create a new
+package and add all the headers and source files from the include/ and code/ directories. Set the temporary output folder
+to obj/, for example, and redirect the output folder to bin/. Then build the library - it should compile and link fine.
+
+The last step is to integrate the library into your project. This is basically the same task as described in the
+"Using the pre-built libraries" section above: add the include/ and bin/ directories to your IDE's paths so that the compiler can find
+the library files. Alternatively you can simply add the assimp project to your project's overall solution and build it inside
+your solution.
+
+
+@section use_noboost Building without boost.
+
+The Boost-Workaround consists of dummy replacements for some boost utility templates. Currently there are replacements for
+
+ - boost.scoped_ptr
+ - boost.scoped_array
+ - boost.format
+ - boost.random
+ - boost.common_factor
+ - boost.foreach
+ - boost.tuple
+ - boost.make_shared
+
+These implementations are very limited and are not intended for use outside assimp. A compiler
+with full support for partial template specializations is required. To enable the workaround, put the following in
+your compiler's list of predefined macros:
+@code
+#define ASSIMP_BUILD_BOOST_WORKAROUND
+@endcode
+<br>
+If you're working with the provided solutions for Visual Studio use the <i>-noboost</i> build configs. <br>
+
+<b>assimp_BUILD_BOOST_WORKAROUND</b> implies <b>assimp_BUILD_SINGLETHREADED</b>. <br>
+See the @ref assimp_st section
+for more details.
+
+
+
+
+@section assimp_dll Windows DLL Build
+
+assimp can be built as DLL. You just need to select a -dll config from the list of project
+configs and you're fine.
+
+<b>NOTE:</b> Theoretically, assimp-dll can be used with multithreaded (non-dll) runtime libraries,
+as long as you don't utilize any non-public stuff from the code folder. However, if you happen
+to encounter *very* strange problems, try changing the runtime to <i>Multithreaded (Debug) DLL</i>.
+
+@section assimp_stlport Building against STLport
+
+STLport is a free, fast and secure STL replacement that works with
+all major compilers and platforms. To get it, download the latest release from
+<a href="http://www.stlport.org"/><stlport.org></a>.
+Usually you'll just need to run 'configure' + a makefile (see their README for more details).
+Don't miss to add <stlport_root>/stlport to your compiler's default include paths - <b>prior</b>
+to the directory where your compiler vendor's headers lie. Do the same for  <stlport_root>/lib and
+recompile assimp. To ensure you're really building against STLport see aiGetCompileFlags().
+<br>
+In our testing, STLport builds tend to be a bit faster than builds against Microsoft's
+C++ Standard Library.
+
+*/
+
+
+/**
+@page usage Usage
+
+@section access_cpp Access by C++ class interface
+
+The assimp library can be accessed by both a class or flat function interface. The C++ class
+interface is the preferred way of interaction: you create an instance of class Assimp::Importer,
+maybe adjust some settings of it and then call Assimp::Importer::ReadFile(). The class will
+read the files and process its data, handing back the imported data as a pointer to an aiScene
+to you. You can now extract the data you need from the file. The importer manages all the resources
+for itsself. If the importer is destroyed, all the data that was created/read by it will be
+destroyed, too. So the easiest way to use the Importer is to create an instance locally, use its
+results and then simply let it go out of scope.
+
+C++ example:
+@code
+#include <assimp/Importer.hpp>      // C++ importer interface
+#include <assimp/scene.h>           // Output data structure
+#include <assimp/postprocess.h>     // Post processing flags
+
+bool DoTheImportThing( const std::string& pFile)
+{
+  // Create an instance of the Importer class
+  Assimp::Importer importer;
+
+  // And have it read the given file with some example postprocessing
+  // Usually - if speed is not the most important aspect for you - you'll
+  // propably to request more postprocessing than we do in this example.
+  const aiScene* scene = importer.ReadFile( pFile,
+	aiProcess_CalcTangentSpace       |
+	aiProcess_Triangulate            |
+	aiProcess_JoinIdenticalVertices  |
+	aiProcess_SortByPType);
+
+  // If the import failed, report it
+  if( !scene)
+  {
+    DoTheErrorLogging( importer.GetErrorString());
+    return false;
+  }
+
+  // Now we can access the file's contents.
+  DoTheSceneProcessing( scene);
+
+  // We're done. Everything will be cleaned up by the importer destructor
+  return true;
+}
+@endcode
+
+What exactly is read from the files and how you interpret it is described at the @ref data page. @endlink The post processing steps that the assimp library can apply to the
+imported data are listed at #aiPostProcessSteps. See the @ref pp Post proccessing page for more details.
+
+Note that the aiScene data structure returned is declared 'const'. Yes, you can get rid of
+these 5 letters with a simple cast. Yes, you may do that. No, it's not recommended (and it's
+suicide in DLL builds if you try to use new or delete on any of the arrays in the scene).
+
+@section access_c Access by plain-c function interface
+
+The plain function interface is just as simple, but requires you to manually call the clean-up
+after you're done with the imported data. To start the import process, call aiImportFile()
+with the filename in question and the desired postprocessing flags like above. If the call
+is successful, an aiScene pointer with the imported data is handed back to you. When you're
+done with the extraction of the data you're interested in, call aiReleaseImport() on the
+imported scene to clean up all resources associated with the import.
+
+C example:
+@code
+#include <assimp/cimport.h>        // Plain-C interface
+#include <assimp/scene.h>          // Output data structure
+#include <assimp/postprocess.h>    // Post processing flags
+
+bool DoTheImportThing( const char* pFile)
+{
+  // Start the import on the given file with some example postprocessing
+  // Usually - if speed is not the most important aspect for you - you'll t
+  // probably to request more postprocessing than we do in this example.
+  const aiScene* scene = aiImportFile( pFile,
+    aiProcess_CalcTangentSpace       |
+	aiProcess_Triangulate            |
+	aiProcess_JoinIdenticalVertices  |
+	aiProcess_SortByPType);
+
+  // If the import failed, report it
+  if( !scene)
+  {
+    DoTheErrorLogging( aiGetErrorString());
+    return false;
+  }
+
+  // Now we can access the file's contents
+  DoTheSceneProcessing( scene);
+
+  // We're done. Release all resources associated with this import
+  aiReleaseImport( scene);
+  return true;
+}
+@endcode
+
+@section custom_io Using custom IO logic with the C++ class interface
+
+The assimp library needs to access files internally. This of course applies to the file you want
+to read, but also to additional files in the same folder for certain file formats. By default,
+standard C/C++ IO logic is used to access these files. If your application works in a special
+environment where custom logic is needed to access the specified files, you have to supply
+custom implementations of IOStream and IOSystem. A shortened example might look like this:
+
+@code
+#include <assimp/IOStream.hpp>
+#include <assimp/IOSystem.hpp>
+
+// My own implementation of IOStream
+class MyIOStream : public Assimp::IOStream
+{
+  friend class MyIOSystem;
+
+protected:
+  // Constructor protected for private usage by MyIOSystem
+  MyIOStream(void);
+
+public:
+  ~MyIOStream(void);
+  size_t Read( void* pvBuffer, size_t pSize, size_t pCount) { ... }
+  size_t Write( const void* pvBuffer, size_t pSize, size_t pCount) { ... }
+  aiReturn Seek( size_t pOffset, aiOrigin pOrigin) { ... }
+  size_t Tell() const { ... }
+  size_t FileSize() const { ... }
+  void Flush () { ... }
+};
+
+// Fisher Price - My First Filesystem
+class MyIOSystem : public Assimp::IOSystem
+{
+  MyIOSystem() { ... }
+  ~MyIOSystem() { ... }
+
+  // Check whether a specific file exists
+  bool Exists( const std::string& pFile) const {
+    ..
+  }
+
+  // Get the path delimiter character we'd like to see
+  char GetOsSeparator() const {
+    return '/';
+  }
+
+  // ... and finally a method to open a custom stream
+  IOStream* Open( const std::string& pFile, const std::string& pMode) {
+	return new MyIOStream( ... );
+  }
+
+  void Close( IOStream* pFile) { delete pFile; }
+};
+@endcode
+
+Now that your IO system is implemented, supply an instance of it to the Importer object by calling
+Assimp::Importer::SetIOHandler().
+
+@code
+void DoTheImportThing( const std::string& pFile)
+{
+  Assimp::Importer importer;
+  // put my custom IO handling in place
+  importer.SetIOHandler( new MyIOSystem());
+
+  // the import process will now use this implementation to access any file
+  importer.ReadFile( pFile, SomeFlag | SomeOtherFlag);
+}
+@endcode
+
+
+@section custom_io_c Using custom IO logic with the plain-c function interface
+
+The C interface also provides a way to override the file system. Control is not as fine-grained as for C++ although
+surely enough for almost any purpose. The process is simple:
+
+<ul>
+<li> Include cfileio.h
+<li> Fill an aiFileIO structure with custom file system callbacks (they're self-explanatory as they work similar to the CRT's fXXX functions)
+<li> .. and pass it as parameter to #aiImportFileEx
+</ul>
+
+@section  logging Logging
+
+The assimp library provides an easy mechanism to log messages. For instance if you want to check the state of your
+import and you just want to see, after which preprocessing step the import-process was aborted you can take a look
+into the log.
+Per default the assimp-library provides a default log implementation, where you can log your user specific message
+by calling it as a singleton with the requested logging-type. To see how this works take a look to this:
+
+@code
+using namespace Assimp;
+
+// Create a logger instance
+DefaultLogger::create("",Logger::VERBOSE);
+
+// Now I am ready for logging my stuff
+DefaultLogger::get()->info("this is my info-call");
+
+// Kill it after the work is done
+DefaultLogger::kill();
+@endcode
+
+At first you have to create the default-logger-instance (create). Now you are ready to rock and can log a
+little bit around. After that you should kill it to release the singleton instance.
+
+If you want to integrate the assimp-log into your own GUI it my be helpful to have a mechanism writing
+the logs into your own log windows. The logger interface provides this by implementing an interface called LogStream.
+You can attach and detach this log stream to the default-logger instance or any implementation derived from Logger.
+Just derivate your own logger from the abstract base class LogStream and overwrite the write-method:
+
+@code
+// Example stream
+class myStream :
+	public LogStream
+{
+public:
+	// Constructor
+	myStream()
+	{
+		// empty
+	}
+
+	// Destructor
+	~myStream()
+	{
+		// empty
+	}
+
+	// Write womethink using your own functionality
+	void write(const char* message)
+	{
+		::printf("%s\n", message);
+	}
+};
+
+// Select the kinds of messages you want to receive on this log stream
+const unsigned int severity = Logger::DEBUGGING|Logger::INFO|Logger::ERR|Logger::WARN;
+
+// Attaching it to the default logger
+Assimp::DefaultLogger::get()->attachStream( new myStream(), severity );
+
+@endcode
+
+The severity level controls the kind of message which will be written into
+the attached stream. If you just want to log errors and warnings set the warn
+and error severity flag for those severities. It is also possible to remove
+a self defined logstream from an error severity by detaching it with the severity
+flag set:
+
+@code
+
+unsigned int severity = 0;
+severity |= Logger::DEBUGGING;
+
+// Detach debug messages from you self defined stream
+Assimp::DefaultLogger::get()->attachStream( new myStream(), severity );
+
+@endcode
+
+If you want to implement your own logger just derive from the abstract base class
+#Logger and overwrite the methods debug, info, warn and error.
+
+If you want to see the debug-messages in a debug-configured build, the Logger-interface
+provides a logging-severity. You can set it calling the following method:
+
+@code
+
+Assimp::DefaultLogger::get()->setLogSeverity( LogSeverity log_severity );
+
+@endcode
+
+The normal logging severity supports just the basic stuff like, info, warnings and errors.
+In the verbose level very fine-grained debug messages will be logged, too. Note that this
+kind kind of logging might decrease import performance.
+*/
+
+/**
+@page data Data Structures
+
+The assimp library returns the imported data in a collection of structures. aiScene forms the root
+of the data, from here you gain access to all the nodes, meshes, materials, animations or textures
+that were read from the imported file. The aiScene is returned from a successful call to
+assimp::Importer::ReadFile(), aiImportFile() or aiImportFileEx() - see the @link usage Usage page @endlink
+for further information on how to use the library.
+
+By default, all 3D data is provided in a right-handed coordinate system such as OpenGL uses. In
+this coordinate system, +X points to the right, -Z points away from the viewer into the screen and
++Y points upwards. Several modeling packages such as 3D Studio Max use this coordinate system as well (or a rotated variant of it).
+By contrast, some other environments use left-handed coordinate systems, a prominent example being
+DirectX. If you need the imported data to be in a left-handed coordinate system, supply the
+#aiProcess_MakeLeftHanded flag to the ReadFile() function call.
+
+The output face winding is counter clockwise. Use #aiProcess_FlipWindingOrder to get CW data.
+@code
+x2
+
+            x1
+	x0
+@endcode
+
+Outputted polygons can be literally everything: they're probably concave, self-intersecting or non-planar,
+although our built-in triangulation (#aiProcess_Triangulate postprocessing step) doesn't handle the two latter.
+
+The output UV coordinate system has its origin in the lower-left corner:
+@code
+0y|1y ---------- 1x|1y
+ |                |
+ |                |
+ |                |
+0x|0y ---------- 1x|0y
+@endcode
+Use the #aiProcess_FlipUVs flag to get UV coordinates with the upper-left corner als origin.
+
+All matrices in the library are row-major. That means that the matrices are stored row by row in memory,
+which is similar to the OpenGL matrix layout. A typical 4x4 matrix including a translational part looks like this:
+@code
+X1  Y1  Z1  T1
+X2  Y2  Z2  T2
+X3  Y3  Z3  T3
+0   0   0   1
+@endcode
+
+... with (X1, X2, X3) being the X base vector, (Y1, Y2, Y3) being the Y base vector, (Z1, Z2, Z3)
+being the Z base vector and (T1, T2, T3) being the translation part. If you want to use these matrices
+in DirectX functions, you have to transpose them.
+
+<hr>
+
+<b>11.24.09:</b> We changed the orientation of our quaternions to the most common convention to avoid confusion.
+However, if you're a previous user of Assimp and you update the library to revisions beyond SVNREV 502,
+you have to adapt your animation loading code to match the new quaternion orientation.
+
+<hr>
+
+@section hierarchy The Node Hierarchy
+
+Nodes are little named entities in the scene that have a place and orientation relative to their parents.
+Starting from the scene's root node all nodes can have 0 to x child nodes, thus forming a hierarchy.
+They form the base on which the scene is built on: a node can refer to 0..x meshes, can be referred to
+by a bone of a mesh or can be animated by a key sequence of an animation. DirectX calls them "frames",
+others call them "objects", we call them aiNode.
+
+A node can potentially refer to single or multiple meshes. The meshes are not stored inside the node, but
+instead in an array of aiMesh inside the aiScene. A node only refers to them by their array index. This also means
+that multiple nodes can refer to the same mesh, which provides a simple form of instancing. A mesh referred to
+by this way lives in the node's local coordinate system. If you want the mesh's orientation in global
+space, you'd have to concatenate the transformations from the referring node and all of its parents.
+
+Most of the file formats don't really support complex scenes, though, but a single model only. But there are
+more complex formats such as .3ds, .x or .collada scenes which may contain an arbitrary complex
+hierarchy of nodes and meshes. I for myself would suggest a recursive filter function such as the
+following pseudocode:
+
+@code
+void CopyNodesWithMeshes( aiNode node, SceneObject targetParent, Matrix4x4 accTransform)
+{
+  SceneObject parent;
+  Matrix4x4 transform;
+
+  // if node has meshes, create a new scene object for it
+  if( node.mNumMeshes > 0)
+  {
+    SceneObjekt newObject = new SceneObject;
+    targetParent.addChild( newObject);
+    // copy the meshes
+    CopyMeshes( node, newObject);
+
+    // the new object is the parent for all child nodes
+    parent = newObject;
+    transform.SetUnity();
+  } else
+  {
+    // if no meshes, skip the node, but keep its transformation
+    parent = targetParent;
+    transform = node.mTransformation * accTransform;
+  }
+
+  // continue for all child nodes
+  for( all node.mChildren)
+    CopyNodesWithMeshes( node.mChildren[a], parent, transform);
+}
+@endcode
+
+This function copies a node into the scene graph if it has children. If yes, a new scene object
+is created for the import node and the node's meshes are copied over. If not, no object is created.
+Potential child objects will be added to the old targetParent, but there transformation will be correct
+in respect to the global space. This function also works great in filtering the bone nodes - nodes
+that form the bone hierarchy for another mesh/node, but don't have any mesh themselves.
+
+@section meshes Meshes
+
+All meshes of an imported scene are stored in an array of aiMesh* inside the aiScene. Nodes refer
+to them by their index in the array and providing the coordinate system for them, too. One mesh uses
+only a single material everywhere - if parts of the model use a different material, this part is
+moved to a separate mesh at the same node. The mesh refers to its material in the same way as the
+node refers to its meshes: materials are stored in an array inside aiScene, the mesh stores only
+an index into this array.
+
+An aiMesh is defined by a series of data channels. The presence of these data channels is defined
+by the contents of the imported file: by default there are only those data channels present in the mesh
+that were also found in the file. The only channels guarenteed to be always present are aiMesh::mVertices
+and aiMesh::mFaces. You can test for the presence of other data by testing the pointers against NULL
+or use the helper functions provided by aiMesh. You may also specify several post processing flags
+at Importer::ReadFile() to let assimp calculate or recalculate additional data channels for you.
+
+At the moment, a single aiMesh may contain a set of triangles and polygons. A single vertex does always
+have a position. In addition it may have one normal, one tangent and bitangent, zero to AI_MAX_NUMBER_OF_TEXTURECOORDS
+(4 at the moment) texture coords and zero to AI_MAX_NUMBER_OF_COLOR_SETS (4) vertex colors. In addition
+a mesh may or may not have a set of bones described by an array of aiBone structures. How to interpret
+the bone information is described later on.
+
+@section material Materials
+
+See the @link materials Material System Page. @endlink
+
+@section bones Bones
+
+A mesh may have a set of bones in the form of aiBone structures.. Bones are a means to deform a mesh
+according to the movement of a skeleton. Each bone has a name and a set of vertices on which it has influence.
+Its offset matrix declares the transformation needed to transform from mesh space to the local space of this bone.
+
+Using the bones name you can find the corresponding node in the node hierarchy. This node in relation
+to the other bones' nodes defines the skeleton of the mesh. Unfortunately there might also be
+nodes which are not used by a bone in the mesh, but still affect the pose of the skeleton because
+they have child nodes which are bones. So when creating the skeleton hierarchy for a mesh I
+suggest the following method:
+
+a) Create a map or a similar container to store which nodes are necessary for the skeleton.
+Pre-initialise it for all nodes with a "no". <br>
+b) For each bone in the mesh: <br>
+b1) Find the corresponding node in the scene's hierarchy by comparing their names. <br>
+b2) Mark this node as "yes" in the necessityMap. <br>
+b3) Mark all of its parents the same way until you 1) find the mesh's node or 2) the parent of the mesh's node. <br>
+c) Recursively iterate over the node hierarchy <br>
+c1) If the node is marked as necessary, copy it into the skeleton and check its children <br>
+c2) If the node is marked as not necessary, skip it and do not iterate over its children. <br>
+
+Reasons: you need all the parent nodes to keep the transformation chain intact. For most
+file formats and modelling packages the node hierarchy of the skeleton is either a child
+of the mesh node or a sibling of the mesh node but this is by no means a requirement so you shouldn't rely on it.
+The node closest to the root node is your skeleton root, from there you
+start copying the hierarchy. You can skip every branch without a node being a bone in the mesh -
+that's why the algorithm skips the whole branch if the node is marked as "not necessary".
+
+You should now have a mesh in your engine with a skeleton that is a subset of the imported hierarchy.
+
+@section anims Animations
+
+An imported scene may contain zero to x aiAnimation entries. An animation in this context is a set
+of keyframe sequences where each sequence describes the orientation of a single node in the hierarchy
+over a limited time span. Animations of this kind are usually used to animate the skeleton of
+a skinned mesh, but there are other uses as well.
+
+An aiAnimation has a duration. The duration as well as all time stamps are given in ticks. To get
+the correct timing, all time stamp thus have to be divided by aiAnimation::mTicksPerSecond. Beware,
+though, that certain combinations of file format and exporter don't always store this information
+in the exported file. In this case, mTicksPerSecond is set to 0 to indicate the lack of knowledge.
+
+The aiAnimation consists of a series of aiNodeAnim's. Each bone animation affects a single node in
+the node hierarchy only, the name specifying which node is affected. For this node the structure
+stores three separate key sequences: a vector key sequence for the position, a quaternion key sequence
+for the rotation and another vector key sequence for the scaling. All 3d data is local to the
+coordinate space of the node's parent, that means in the same space as the node's transformation matrix.
+There might be cases where animation tracks refer to a non-existent node by their name, but this
+should not be the case in your every-day data.
+
+To apply such an animation you need to identify the animation tracks that refer to actual bones
+in your mesh. Then for every track: <br>
+a) Find the keys that lay right before the current anim time. <br>
+b) Optional: interpolate between these and the following keys. <br>
+c) Combine the calculated position, rotation and scaling to a tranformation matrix <br>
+d) Set the affected node's transformation to the calculated matrix. <br>
+
+If you need hints on how to convert to or from quaternions, have a look at the
+<a href="http://www.j3d.org/matrix_faq/matrfaq_latest.html">Matrix&Quaternion FAQ</a>. I suggest
+using logarithmic interpolation for the scaling keys if you happen to need them - usually you don't
+need them at all.
+
+@section textures Textures
+
+Normally textures used by assets are stored in separate files, however,
+there are file formats embedding their textures directly into the model file.
+Such textures are loaded into an aiTexture structure.
+<br>
+There are two cases:
+<br>
+<b>1)</b> The texture is NOT compressed. Its color data is directly stored
+in the aiTexture structure as an array of aiTexture::mWidth * aiTexture::mHeight aiTexel structures. Each aiTexel represents a pixel (or "texel") of the texture
+image. The color data is stored in an unsigned RGBA8888 format, which can be easily used for
+both Direct3D and OpenGL (swizzling the order of the color components might be necessary).
+RGBA8888 has been chosen because it is well-known, easy to use and natively
+supported by nearly all graphics APIs.
+<br>
+<b>2)</b> This applies if aiTexture::mHeight == 0 is fullfilled. Then, texture is stored in a
+"compressed" format such as DDS or PNG. The term "compressed" does not mean that the
+texture data must actually be compressed, however the texture was found in the
+model file as if it was stored in a separate file on the harddisk. Appropriate
+decoders (such as libjpeg, libpng, D3DX, DevIL) are required to load theses textures.
+aiTexture::mWidth specifies the size of the texture data in bytes, aiTexture::pcData is
+a pointer to the raw image data and aiTexture::achFormatHint is either zeroed or
+contains the most common file extension of the embedded texture's format. This value is only
+set if assimp is able to determine the file format.
+*/
+
+
+/**
+@page materials Material System
+
+@section General Overview
+All materials are stored in an array of aiMaterial inside the aiScene.
+
+Each aiMesh refers to one
+material by its index in the array. Due to the vastly diverging definitions and usages of material
+parameters there is no hard definition of a material structure. Instead a material is defined by
+a set of properties accessible by their names. Have a look at assimp/material.h to see what types of
+properties are defined. In this file there are also various functions defined to test for the
+presence of certain properties in a material and retrieve their values.
+
+@section mat_tex Textures
+
+Textures are organized in stacks, each stack being evaluated independently. The final color value from a particular texture stack is used in the shading equation. For example, the computed color value of the diffuse texture stack (aiTextureType_DIFFUSE) is multipled with the amount of incoming diffuse light to obtain the final diffuse color of a pixel.
+
+@code
+
+ Stack                               Resulting equation
+
+------------------------
+| Constant base color  |             color
+------------------------
+| Blend operation 0    |             +
+------------------------
+| Strength factor 0    |             0.25*
+------------------------
+| Texture 0            |             texture_0
+------------------------
+| Blend operation 1    |             *
+------------------------
+| Strength factor 1    |             1.0*
+------------------------
+| Texture 1            |             texture_1
+------------------------
+  ...                                ...
+
+@endcode
+
+@section keys Constants
+
+All material key constants start with 'AI_MATKEY' (it's an ugly macro for historical reasons, don't ask).
+
+<table border="1">
+  <tr>
+    <th>Name</th>
+    <th>Data Type</th>
+    <th>Default Value</th>
+	<th>Meaning</th>
+	<th>Notes</th>
+  </tr>
+  <tr>
+    <td><tt>NAME</tt></td>
+    <td>aiString</td>
+    <td>n/a</td>
+	<td>The name of the material, if available. </td>
+	<td>Ignored by <tt>aiProcess_RemoveRedundantMaterials</tt>. Materials are considered equal even if their names are different.</td>
+  </tr>
+  <tr>
+    <td><tt>COLOR_DIFFUSE</tt></td>
+    <td>aiColor3D</td>
+    <td>black (0,0,0)</td>
+	<td>Diffuse color of the material. This is typically scaled by the amount of incoming diffuse light (e.g. using gouraud shading) </td>
+	<td>---</td>
+  </tr>
+  <tr>
+    <td><tt>COLOR_SPECULAR</tt></td>
+    <td>aiColor3D</td>
+    <td>black (0,0,0)</td>
+	<td>Specular color of the material. This is typically scaled by the amount of incoming specular light (e.g. using phong shading) </td>
+	<td>---</td>
+  </tr>
+  <tr>
+    <td><tt>COLOR_AMBIENT</tt></td>
+    <td>aiColor3D</td>
+    <td>black (0,0,0)</td>
+	<td>Ambient color of the material. This is typically scaled by the amount of ambient light </td>
+	<td>---</td>
+  </tr>
+  <tr>
+    <td><tt>COLOR_EMISSIVE</tt></td>
+    <td>aiColor3D</td>
+    <td>black (0,0,0)</td>
+	<td>Emissive color of the material. This is the amount of light emitted by the object. In real time applications it will usually not affect surrounding objects, but raytracing applications may wish to treat emissive objects as light sources. </td>
+	<td>---</tt></td>
+  </tr>
+
+  <tr>
+    <td><tt>COLOR_TRANSPARENT</tt></td>
+    <td>aiColor3D</td>
+    <td>black (0,0,0)</td>
+	<td>Defines the transparent color of the material, this is the color to be multiplied with the color of
+	translucent light to construct the final 'destination color' for a particular position in the screen buffer. T </td>
+	<td>---</tt></td>
+  </tr>
+
+  <tr>
+    <td><tt>WIREFRAME</tt></td>
+    <td>int</td>
+    <td>false</td>
+	<td>Specifies whether wireframe rendering must be turned on for the material. 0 for false, !0 for true. </td>
+	<td>---</tt></td>
+  </tr>
+
+  <tr>
+    <td><tt>TWOSIDED</tt></td>
+    <td>int</td>
+    <td>false</td>
+	<td>Specifies whether meshes using this material must be rendered without backface culling. 0 for false, !0 for true. </td>
+	<td>Some importers set this property if they don't know whether the output face oder is right. As long as it is not set, you may safely enable backface culling.</tt></td>
+  </tr>
+
+  <tr>
+    <td><tt>SHADING_MODEL</tt></td>
+    <td>int</td>
+    <td>gouraud</td>
+	<td>One of the #aiShadingMode enumerated values. Defines the library shading model to use for (real time) rendering to approximate the original look of the material as closely as possible. </td>
+	<td>The presence of this key might indicate a more complex material. If absent, assume phong shading only if a specular exponent is given.</tt></td>
+  </tr>
+
+  <tr>
+    <td><tt>BLEND_FUNC</tt></td>
+    <td>int</td>
+    <td>false</td>
+	<td>One of the #aiBlendMode enumerated values. Defines how the final color value in the screen buffer is computed from the given color at that position and the newly computed color from the material. Simply said, alpha blending settings.</td>
+	<td>-</td>
+  </tr>
+
+  <tr>
+    <td><tt>OPACITY</tt></td>
+    <td>float</td>
+    <td>1.0</td>
+	<td>Defines the opacity of the material in a range between 0..1.</td>
+	<td>Use this value to decide whether you have to activate alpha blending for rendering. <tt>OPACITY</tt> != 1 usually also implies TWOSIDED=1 to avoid cull artifacts.</td>
+  </tr>
+
+  <tr>
+    <td><tt>SHININESS</tt></td>
+    <td>float</td>
+    <td>0.f</td>
+	<td>Defines the shininess of a phong-shaded material. This is actually the exponent of the phong specular equation</td>
+	<td><tt>SHININESS</tt>=0 is equivalent to <tt>SHADING_MODEL</tt>=<tt>aiShadingMode_Gouraud</tt>.</td>
+  </tr>
+
+  <tr>
+    <td><tt>SHININESS_STRENGTH</tt></td>
+    <td>float</td>
+    <td>1.0</td>
+	<td>Scales the specular color of the material.</td>
+	<td>This value is kept separate from the specular color by most modelers, and so do we.</td>
+  </tr>
+
+  <tr>
+    <td><tt>REFRACTI</tt></td>
+    <td>float</td>
+    <td>1.0</td>
+	<td>Defines the Index Of Refraction for the material. That's not supported by most file formats.</td>
+	<td>Might be of interest for raytracing.</td>
+  </tr>
+
+  <tr>
+    <td><tt>TEXTURE(t,n)</tt></td>
+    <td>aiString</td>
+    <td>n/a</td>
+	<td>Defines the path to the n'th texture on the stack 't', where 'n' is any value >= 0 and 't' is one of the #aiTextureType enumerated values.</td>
+	<td>See the 'Textures' section above.</td>
+  </tr>
+
+  <tr>
+    <td><tt>TEXBLEND(t,n)</tt></td>
+    <td>float</td>
+    <td>n/a</td>
+	<td>Defines the strength the n'th texture on the stack 't'. All color components (rgb) are multipled with this factor *before* any further processing is done.</td>
+	<td>-</td>
+  </tr>
+
+  <tr>
+    <td><tt>TEXOP(t,n)</tt></td>
+    <td>int</td>
+    <td>n/a</td>
+	<td>One of the #aiTextureOp enumerated values. Defines the arithmetic operation to be used to combine the n'th texture on the stack 't' with the n-1'th. <tt>TEXOP(t,0)</tt> refers to the blend operation between the base color for this stack (e.g. <tt>COLOR_DIFFUSE</tt> for the diffuse stack) and the first texture.</td>
+	<td>-</td>
+  </tr>
+
+  <tr>
+    <td><tt>MAPPING(t,n)</tt></td>
+    <td>int</td>
+    <td>n/a</td>
+	<td>Defines how the input mapping coordinates for sampling the n'th texture on the stack 't' are computed. Usually explicit UV coordinates are provided, but some model file formats might also be using basic shapes, such as spheres or cylinders, to project textures onto meshes.</td>
+	<td>See the 'Textures' section below. #aiProcess_GenUVCoords can be used to let Assimp compute proper UV coordinates from projective mappings.</td>
+  </tr>
+
+  <tr>
+    <td><tt>UVWSRC(t,n)</tt></td>
+    <td>int</td>
+    <td>n/a</td>
+	<td>Defines the UV channel to be used as input mapping coordinates for sampling the n'th texture on the stack 't'. All meshes assigned to this material share the same UV channel setup</td>
+	<td>Presence of this key implies <tt>MAPPING(t,n)</tt> to be #aiTextureMapping_UV. See @ref uvwsrc for more details. </td>
+  </tr>
+
+  <tr>
+    <td><tt>MAPPINGMODE_U(t,n)</tt></td>
+    <td>int</td>
+    <td>n/a</td>
+	<td>Any of the #aiTextureMapMode enumerated values. Defines the texture wrapping mode on the x axis for sampling the n'th texture on the stack 't'. 'Wrapping' occurs whenever UVs lie outside the 0..1 range. </td>
+	<td>-</td>
+  </tr>
+
+  <tr>
+    <td><tt>MAPPINGMODE_V(t,n)</tt></td>
+    <td>int</td>
+    <td>n/a</td>
+	<td>Wrap mode on the v axis. See <tt>MAPPINGMODE_U</tt>. </td>
+	<td>-</td>
+  </tr>
+
+   <tr>
+    <td><tt>TEXMAP_AXIS(t,n)</tt></td>
+    <td>aiVector3D</td>
+    <td>n/a</td>
+	<td></tt> Defines the base axis to to compute the mapping coordinates for the n'th texture on the stack 't' from. This is not required for UV-mapped textures. For instance, if <tt>MAPPING(t,n)</tt> is #aiTextureMapping_SPHERE, U and V would map to longitude and latitude of a sphere around the given axis. The axis is given in local mesh space.</td>
+	<td>-</td>
+  </tr>
+
+  <tr>
+    <td><tt>TEXFLAGS(t,n)</tt></td>
+    <td>int</td>
+    <td>n/a</td>
+	<td></tt> Defines miscellaneous flag for the n'th texture on the stack 't'. This is a bitwise combination of the #aiTextureFlags enumerated values.</td>
+	<td>-</td>
+  </tr>
+
+</table>
+
+@section cpp C++-API
+
+Retrieving a property from a material is done using various utility functions. For C++ it's simply calling aiMaterial::Get()
+
+@code
+
+aiMaterial* mat = .....
+
+// The generic way
+if(AI_SUCCESS != mat->Get(<material-key>,<where-to-store>)) {
+   // handle epic failure here
+}
+
+@endcode
+
+Simple, isn't it? To get the name of a material you would use
+
+@code
+
+aiString name;
+mat->Get(AI_MATKEY_NAME,name);
+
+@endcode
+
+Or for the diffuse color ('color' won't be modified if the property is not set)
+
+@code
+
+aiColor3D color (0.f,0.f,0.f);
+mat->Get(AI_MATKEY_COLOR_DIFFUSE,color);
+
+@endcode
+
+<b>Note:</b> Get() is actually a template with explicit specializations for aiColor3D, aiColor4D, aiString, float, int and some others.
+Make sure that the type of the second parameter matches the expected data type of the material property (no compile-time check yet!).
+Don't follow this advice if you wish to encounter very strange results.
+
+@section C C-API
+
+For good old C it's slightly different. Take a look at the aiGetMaterialGet<data-type> functions.
+
+@code
+
+aiMaterial* mat = .....
+
+if(AI_SUCCESS != aiGetMaterialFloat(mat,<material-key>,<where-to-store>)) {
+   // handle epic failure here
+}
+
+@endcode
+
+To get the name of a material you would use
+
+@code
+
+aiString name;
+aiGetMaterialString(mat,AI_MATKEY_NAME,&name);
+
+@endcode
+
+Or for the diffuse color ('color' won't be modified if the property is not set)
+
+@code
+
+aiColor3D color (0.f,0.f,0.f);
+aiGetMaterialColor(mat,AI_MATKEY_COLOR_DIFFUSE,&color);
+
+@endcode
+
+@section uvwsrc How to map UV channels to textures (MATKEY_UVWSRC)
+
+The MATKEY_UVWSRC property is only present if the source format doesn't specify an explicit mapping from
+textures to UV channels. Many formats don't do this and assimp is not aware of a perfect rule either.
+
+Your handling of UV channels needs to be flexible therefore. Our recommendation is to use logic like this
+to handle most cases properly:
+
+@verbatim
+have only one uv channel?
+   assign channel 0 to all textures and break
+
+for all textures
+   have uvwsrc for this texture?
+      assign channel specified in uvwsrc
+   else
+      assign channels in ascending order for all texture stacks,
+	    i.e. diffuse1 gets channel 1, opacity0 gets channel 0.
+
+@endverbatim
+
+@section pseudo Pseudo Code Listing
+
+For completeness, the following is a very rough pseudo-code sample showing how to evaluate Assimp materials in your
+shading pipeline. You'll probably want to limit your handling of all those material keys to a reasonable subset suitable for your purposes
+(for example most 3d engines won't support highly complex multi-layer materials, but many 3d modellers do).
+
+Also note that this sample is targeted at a (shader-based) rendering pipeline for real time graphics.
+
+@code
+
+// ---------------------------------------------------------------------------------------
+// Evaluate multiple textures stacked on top of each other
+float3 EvaluateStack(stack)
+{
+  // For the 'diffuse' stack stack.base_color would be COLOR_DIFFUSE
+  // and TEXTURE(aiTextureType_DIFFUSE,n) the n'th texture.
+
+  float3 base = stack.base_color;
+  for (every texture in stack)
+  {
+    // assuming we have explicit & pretransformed UVs for this texture
+    float3 color = SampleTexture(texture,uv);
+
+    // scale by texture blend factor
+    color *= texture.blend;
+
+    if (texture.op == add)
+      base += color;
+    else if (texture.op == multiply)
+      base *= color;
+    else // other blend ops go here
+  }
+  return base;
+}
+
+// ---------------------------------------------------------------------------------------
+// Compute the diffuse contribution for a pixel
+float3 ComputeDiffuseContribution()
+{
+  if (shading == none)
+     return float3(1,1,1);
+
+  float3 intensity (0,0,0);
+  for (all lights in range)
+  {
+    float fac = 1.f;
+    if (shading == gouraud)
+      fac =  lambert-term ..
+    else // other shading modes go here
+
+    // handling of different types of lights, such as point or spot lights
+    // ...
+
+    // and finally sum the contribution of this single light ...
+    intensity += light.diffuse_color * fac;
+  }
+  // ... and combine the final incoming light with the diffuse color
+  return EvaluateStack(diffuse) * intensity;
+}
+
+// ---------------------------------------------------------------------------------------
+// Compute the specular contribution for a pixel
+float3 ComputeSpecularContribution()
+{
+  if (shading == gouraud || specular_strength == 0 || specular_exponent == 0)
+    return float3(0,0,0);
+
+  float3 intensity (0,0,0);
+  for (all lights in range)
+  {
+    float fac = 1.f;
+    if (shading == phong)
+      fac =  phong-term ..
+    else // other specular shading modes go here
+
+    // handling of different types of lights, such as point or spot lights
+    // ...
+
+    // and finally sum the specular contribution of this single light ...
+    intensity += light.specular_color * fac;
+  }
+  // ... and combine the final specular light with the specular color
+  return EvaluateStack(specular) * intensity * specular_strength;
+}
+
+// ---------------------------------------------------------------------------------------
+// Compute the ambient contribution for a pixel
+float3 ComputeAmbientContribution()
+{
+  if (shading == none)
+     return float3(0,0,0);
+
+  float3 intensity (0,0,0);
+  for (all lights in range)
+  {
+    float fac = 1.f;
+
+    // handling of different types of lights, such as point or spot lights
+    // ...
+
+    // and finally sum the ambient contribution of this single light ...
+    intensity += light.ambient_color * fac;
+  }
+  // ... and combine the final ambient light with the ambient color
+  return EvaluateStack(ambient) * intensity;
+}
+
+// ---------------------------------------------------------------------------------------
+// Compute the final color value for a pixel
+// @param prev Previous color at that position in the framebuffer
+float4 PimpMyPixel (float4 prev)
+{
+  // .. handle displacement mapping per vertex
+  // .. handle bump/normal mapping
+
+  // Get all single light contribution terms
+  float3 diff = ComputeDiffuseContribution();
+  float3 spec = ComputeSpecularContribution();
+  float3 ambi = ComputeAmbientContribution();
+
+  // .. and compute the final color value for this pixel
+  float3 color = diff + spec + ambi;
+  float3 opac  = EvaluateStack(opacity);
+
+  // note the *slightly* strange meaning of additive and multiplicative blending here ...
+  // those names will most likely be changed in future versions
+  if (blend_func == add)
+       return prev+color*opac;
+  else if (blend_func == multiply)
+       return prev*(1.0-opac)+prev*opac;
+
+   return color;
+}
+
+@endcode
+
+*/
+
+
+
+
+/**
+@page perf Performance
+
+@section perf_overview Overview
+
+This page discusses general performance issues related to assimp.
+
+@section perf_profile Profiling
+
+assimp has built-in support for <i>very</i> basic profiling and time measurement. To turn it on, set the <tt>GLOB_MEASURE_TIME</tt>
+configuration switch to <tt>true</tt> (nonzero). Results are dumped to the log file, so you need to setup
+an appropriate logger implementation with at least one output stream first (see the @link logging Logging Page @endlink
+for the details.).
+
+Note that these measurements are based on a single run of the importer and each of the post processing steps, so
+a single result set is far away from being significant in a statistic sense. While precision can be improved
+by running the test multiple times, the low accuracy of the timings may render the results useless
+for smaller files.
+
+A sample report looks like this (some unrelated log messages omitted, entries grouped for clarity):
+
+@verbatim
+Debug, T5488: START `total`
+Info,  T5488: Found a matching importer for this file format
+
+
+Debug, T5488: START `import`
+Info,  T5488: BlendModifier: Applied the `Subdivision` modifier to `OBMonkey`
+Debug, T5488: END   `import`, dt= 3.516 s
+
+
+Debug, T5488: START `preprocess`
+Debug, T5488: END   `preprocess`, dt= 0.001 s
+Info,  T5488: Entering post processing pipeline
+
+
+Debug, T5488: START `postprocess`
+Debug, T5488: RemoveRedundantMatsProcess begin
+Debug, T5488: RemoveRedundantMatsProcess finished
+Debug, T5488: END   `postprocess`, dt= 0.001 s
+
+
+Debug, T5488: START `postprocess`
+Debug, T5488: TriangulateProcess begin
+Info,  T5488: TriangulateProcess finished. All polygons have been triangulated.
+Debug, T5488: END   `postprocess`, dt= 3.415 s
+
+
+Debug, T5488: START `postprocess`
+Debug, T5488: SortByPTypeProcess begin
+Info,  T5488: Points: 0, Lines: 0, Triangles: 1, Polygons: 0 (Meshes, X = removed)
+Debug, T5488: SortByPTypeProcess finished
+
+Debug, T5488: START `postprocess`
+Debug, T5488: JoinVerticesProcess begin
+Debug, T5488: Mesh 0 (unnamed) | Verts in: 503808 out: 126345 | ~74.922
+Info,  T5488: JoinVerticesProcess finished | Verts in: 503808 out: 126345 | ~74.9
+Debug, T5488: END   `postprocess`, dt= 2.052 s
+
+Debug, T5488: START `postprocess`
+Debug, T5488: FlipWindingOrderProcess begin
+Debug, T5488: FlipWindingOrderProcess finished
+Debug, T5488: END   `postprocess`, dt= 0.006 s
+
+
+Debug, T5488: START `postprocess`
+Debug, T5488: LimitBoneWeightsProcess begin
+Debug, T5488: LimitBoneWeightsProcess end
+Debug, T5488: END   `postprocess`, dt= 0.001 s
+
+
+Debug, T5488: START `postprocess`
+Debug, T5488: ImproveCacheLocalityProcess begin
+Debug, T5488: Mesh 0 | ACMR in: 0.851622 out: 0.718139 | ~15.7
+Info,  T5488: Cache relevant are 1 meshes (251904 faces). Average output ACMR is 0.718139
+Debug, T5488: ImproveCacheLocalityProcess finished.
+Debug, T5488: END   `postprocess`, dt= 1.903 s
+
+
+Info,  T5488: Leaving post processing pipeline
+Debug, T5488: END   `total`, dt= 11.269 s
+@endverbatim
+
+In this particular example only one fourth of the total import time was spent on the actual importing, while the rest of the
+time got consumed by the #aiProcess_Triangulate, #aiProcess_JoinIdenticalVertices and #aiProcess_ImproveCacheLocality
+postprocessing steps. A wise selection of postprocessing steps is therefore essential to getting good performance.
+Of course this depends on the individual requirements of your application, in many of the typical use cases of assimp performance won't
+matter (i.e. in an offline content pipeline).
+*/
+
+/**
+@page threading Threading
+
+@section overview Overview
+
+This page discusses both assimps scalability in threaded environments and the precautions to be taken in order to
+use it from multiple threads concurrently.
+
+@section threadsafety Thread-safety / using Assimp concurrently from several threads
+
+The library can be accessed by multiple threads simultaneously, as long as the
+following prerequisites are fulfilled:
+
+ - Users of the C++-API should ensure that they use a dedicated #Assimp::Importer instance for each thread. Constructing instances of #Assimp::Importer is expensive, so it might be a good idea to
+   let every thread maintain its own thread-local instance (which can be used to
+   load as many files as necessary).
+ - The C-API is thread safe.
+ - When supplying custom IO logic, one must make sure the underlying implementation is thread-safe.
+ - Custom log streams or logger replacements have to be thread-safe, too.
+
+
+
+
+Multiple concurrent imports may or may not be beneficial, however. For certain file formats in conjunction with
+little or no post processing IO times tend to be the performance bottleneck. Intense post processing together
+with 'slow' file formats like X or Collada might scale well with multiple concurrent imports.
+
+
+@section automt Internal threading
+
+Internal multi-threading is not currently implemented.
+*/
+
+/**
+@page res Resources
+
+This page lists some useful resources for assimp. Note that, even though the core team has an eye on them,
+we cannot guarantee the accuracy of third-party information. If in doubt, it's best to ask either on the
+mailing list or on our forums on SF.net.
+
+ - assimp comes with some sample applications, these can be found in the <i>./samples</i> folder. Don't forget to read the <i>README</i> file.
+ - http://www.drivenbynostalgia.com/files/AssimpOpenGLDemo.rar - OpenGl animation sample using the library's animation import facilities.
+ - http://nolimitsdesigns.com/game-design/open-asset-import-library-animation-loader/ is another utility to
+   simplify animation playback.
+ - http://ogldev.atspace.co.uk/www/tutorial22/tutorial22.html - Tutorial "Loading models using the Open Asset Import Library", out of a series of OpenGl tutorials.
+
+*/
+
+
+/**
+@page importer_notes Importer Notes
+
+<hr>
+@section blender Blender
+
+This section contains implementation notes for the Blender3D importer.
+@subsection bl_overview Overview
+
+assimp provides a self-contained reimplementation of Blender's so called SDNA system (http://www.blender.org/development/architecture/notes-on-sdna/).
+SDNA allows Blender to be fully backward and forward compatible and to exchange
+files across all platforms. The BLEND format is thus a non-trivial binary monster and the loader tries to read the most of it,
+naturally limited by the scope of the #aiScene output data structure.
+Consequently, if Blender is the only modeling tool in your asset work flow, consider writing a
+custom exporter from Blender if assimps format coverage does not meet the requirements.
+
+@subsection bl_status Current status
+
+The Blender loader does not support animations yet, but is apart from that considered relatively stable.
+
+@subsection bl_notes Notes
+
+When filing bugs on the Blender loader, always give the Blender version (or, even better, post the file caused the error).
+
+<hr>
+@section ifc IFC
+
+This section contains implementation notes on the IFC-STEP importer.
+@subsection ifc_overview Overview
+
+The library provides a partial implementation of the IFC2x3 industry standard for automatized exchange of CAE/architectural
+data sets. See http://en.wikipedia.org/wiki/Industry_Foundation_Classes for more information on the format. We aim
+at getting as much 3D data out of the files as possible.
+
+@subsection ifc_status Current status
+
+IFC support is new and considered experimental. Please report any bugs you may encounter.
+
+@subsection ifc_notes Notes
+
+- Only the STEP-based encoding is supported. IFCZIP and IFCXML are not (but IFCZIP can simply be unzipped to get a STEP file).
+- The importer leaves vertex coordinates untouched, but applies a global scaling to the root transform to
+  convert from whichever unit the IFC file uses to <i>metres</i>.
+- If multiple geometric representations are provided, the choice which one to load is based on how expensive a representation seems
+ to be in terms of import time. The loader also avoids representation types for which it has known deficits.
+- Not supported are arbitrary binary operations (binary clipping is implemented, though).
+- Of the various relationship types that IFC knows, only aggregation, containment and material assignment are resolved and mapped to
+  the output graph.
+- The implementation knows only about IFC2X3 and applies this rule set to all models it encounters,
+  regardless of their actual version. Loading of older or newer files may fail with parsing errors.
+
+@subsection ifc_metadata Metadata
+
+IFC file properties (IfcPropertySet) are kept as per-node metadata, see aiNode::mMetaData.
+
+<hr>
+@section ogre Ogre
+*ATTENTION*: The Ogre-Loader is currently under development, many things have changed after this documentation was written, but they are not final enough to rewrite the documentation. So things may have changed by now!
+
+This section contains implementations notes for the OgreXML importer.
+@subsection overview Overview
+Ogre importer is currently optimized for the Blender Ogre exporter, because thats the only one that I use. You can find the Blender Ogre exporter at: http://www.ogre3d.org/forums/viewtopic.php?f=8&t=45922
+
+@subsection what What will be loaded?
+
+Mesh: Faces, Positions, Normals and all TexCoords. The Materialname will be used to load the material.
+
+Material: The right material in the file will be searched, the importer should work with materials who
+have 1 technique and 1 pass in this technique. From there, the texturename (for 1 color- and 1 normalmap) and the
+materialcolors (but not in custom materials) will be loaded. Also, the materialname will be set.
+
+Skeleton: Skeleton with Bone hierarchy (Position and Rotation, but no Scaling in the skeleton is supported), names and transformations,
+animations with rotation, translation and scaling keys.
+
+@subsection export_Blender How to export Files from Blender
+You can find informations about how to use the Ogreexporter by your own, so here are just some options that you need, so the assimp
+importer will load everything correctly:
+- Use either "Rendering Material" or "Custom Material" see @ref material
+- do not use "Flip Up Axies to Y"
+- use "Skeleton name follow mesh"
+
+
+@subsection xml XML Format
+There is a binary and a XML mesh Format from Ogre. This loader can only
+Handle xml files, but don't panic, there is a command line converter, which you can use
+to create XML files from Binary Files. Just look on the Ogre page for it.
+
+Currently you can only load meshes. So you will need to import the *.mesh.xml file, the loader will
+try to find the appendant material and skeleton file.
+
+The skeleton file must have the same name as the mesh file, e.g. fish.mesh.xml and fish.skeleton.xml.
+
+@subsection material Materials
+The material file can have the same name as the mesh file (if the file is model.mesh or model.mesh.xml the
+loader will try to load model.material),
+or you can use Importer::Importer::SetPropertyString(AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE, "materiafile.material")
+to specify the name of the material file. This is especially usefull if multiply materials a stored in a single file.
+The importer will first try to load the material with the same name as the mesh and only if this can't be open try
+to load the alternate material file. The default material filename is "Scene.material".
+
+We suggest that you use custom materials, because they support multiple textures (like colormap and normalmap). First of all you
+should read the custom material sektion in the Ogre Blender exporter Help File, and than use the assimp.tlp template, which you
+can find in scripts/OgreImpoter/Assimp.tlp in the assimp source. If you don't set all values, don't worry, they will be ignored during import.
+
+If you want more properties in custom materials, you can easily expand the ogre material loader, it will be just a few lines for each property.
+Just look in OgreImporterMaterial.cpp
+
+@subsection Importer Properties
+-	IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME: Normally, a texture is loaded as a colormap, if no
+	target is specified in the
+	materialfile. Is this switch is enabled, texture names ending with _n, _l, _s
+	are used as normalmaps, lightmaps or specularmaps.
+	<br>
+	Property type: Bool. Default value: false.
+-	IMPORT_OGRE_MATERIAL_FILE: Ogre Meshes contain only the MaterialName, not the MaterialFile.
+	If there
+	is no material file with the same name as the material, Ogre Importer will
+	try to load this file and search the material in it.
+	<br>
+	Property type: String. Default value: guessed.
+
+@subsection todo Todo
+- Load colors in custom materials
+- extend custom and normal material loading
+- fix bone hierarchy bug
+- test everything elaboratly
+- check for non existent animation keys (what happens if a one time not all bones have a key?)
+*/
+
+
+/**
+@page extend Extending the Library
+
+@section General
+
+Or - how to write your own loaders. It's easy. You just need to implement the #Assimp::BaseImporter class,
+which defines a few abstract methods, register your loader, test it carefully and provide test models for it.
+
+OK, that sounds too easy :-). The whole procedure for a new loader merely looks like this:
+
+<ul>
+<li>Create a header (<tt><i>FormatName</i>Importer.h</tt>) and a unit (<tt><i>FormatName</i>Importer.cpp</tt>) in the <tt>&lt;root&gt;/code/</tt> directory</li>
+<li>Add them to the following workspaces: vc8 and vc9 (the files are in the workspaces directory), CMAKE (code/CMakeLists.txt, create a new
+source group for your importer and put them also to ADD_LIBRARY( assimp SHARED))</li>
+<li>Include <i>AssimpPCH.h</i> - this is the PCH file, and it includes already most Assimp-internal stuff. </li>
+<li>Open Importer.cpp and include your header just below the <i>(include_new_importers_here)</i> line,
+guarded by a #define
+@code
+#if (!defined assimp_BUILD_NO_FormatName_IMPORTER)
+	...
+#endif
+@endcode
+Wrap the same guard around your .cpp!</li>
+
+<li>Now advance to the <i>(register_new_importers_here)</i> line in the Importer.cpp and register your importer there - just like all the others do.</li>
+<li>Setup a suitable test environment (i.e. use AssimpView or your own application), make sure to enable
+the #aiProcess_ValidateDataStructure flag and enable verbose logging. That is, simply call before you import anything:
+@code
+DefaultLogger::create("AssimpLog.txt",Logger::VERBOSE)
+@endcode
+</li>
+<li>
+Implement the Assimp::BaseImporter::CanRead(), Assimp::BaseImporter::InternReadFile() and Assimp::BaseImporter::GetExtensionList().
+Just copy'n'paste the template from Appendix A and adapt it for your needs.
+</li>
+<li>For error handling, throw a dynamic allocated ImportErrorException (see Appendix A) for critical errors, and log errors, warnings, infos and debuginfos
+with DefaultLogger::get()->[error, warn, debug, info].
+</li>
+<li>
+Make sure that your loader compiles against all build configurations on all supported platforms. This includes <i>-noboost</i>! To avoid problems,
+see the boost section on this page for a list of all 'allowed' boost classes (again, this grew historically when we had to accept that boost
+is not THAT widely spread that one could rely on it being available everywhere).
+</li>
+<li>
+Provide some _free_ test models in <tt>&lt;root&gt;/test/models/&lt;FormatName&gt;/</tt> and credit their authors.
+Test files for a file format shouldn't be too large (<i>~500 KiB in total</i>), and not too repetive. Try to cover all format features with test data.
+</li>
+<li>
+Done! Please, share your loader that everyone can profit from it!
+</li>
+</ul>
+
+@section properties Properties
+
+You can use properties to chance the behavior of you importer. In order to do so, you have to overide BaseImporter::SetupProperties, and specify
+you custom properties in config.h. Just have a look to the other AI_CONFIG_IMPORT_* defines and you will understand, how it works.
+
+The properties can be set with Importer::SetProperty***() and can be accessed in your SetupProperties function with Importer::GetProperty***(). You can
+store the properties as a member variable of your importer, they are thread safe.
+
+@section tnote Notes for text importers
+
+<ul>
+<li>Try to make your parser as flexible as possible. Don't rely on particular layout, whitespace/tab style,
+except if the file format has a strict definition, in which case you should always warn about spec violations.
+But the general rule of thumb is <i>be strict in what you write and tolerant in what you accept</i>.</li>
+<li>Call Assimp::BaseImporter::ConvertToUTF8() before you parse anything to convert foreign encodings to UTF-8.
+ That's not necessary for XML importers, which must use the provided IrrXML for reading. </li>
+</ul>
+
+@section bnote Notes for binary importers
+
+<ul>
+<li>
+Take care of endianess issues! Assimp importers mostly support big-endian platforms, which define the <tt>AI_BUILD_BIG_ENDIAN</tt> constant.
+See the next section for a list of utilities to simplify this task.
+</li>
+<li>
+Don't trust the input data! Check all offsets!
+</li>
+</ul>
+
+@section util Utilities
+
+Mixed stuff for internal use by loaders, mostly documented (most of them are already included by <i>AssimpPCH.h</i>):
+<ul>
+<li><b>ByteSwapper</b> (<i>ByteSwapper.h</i>) - manual byte swapping stuff for binary loaders.</li>
+<li><b>StreamReader</b> (<i>StreamReader.h</i>) - safe, endianess-correct, binary reading.</li>
+<li><b>IrrXML</b> (<i>irrXMLWrapper.h</i>)  - for XML-parsing (SAX.</li>
+<li><b>CommentRemover</b> (<i>RemoveComments.h</i>) - remove single-line and multi-line comments from a text file.</li>
+<li>fast_atof, strtoul10, strtoul16, SkipSpaceAndLineEnd, SkipToNextToken .. large family of low-level
+parsing functions, mostly declared in <i>fast_atof.h</i>, <i>StringComparison.h</i> and <i>ParsingUtils.h</i> (a collection that grew
+historically, so don't expect perfect organization). </li>
+<li><b>ComputeNormalsWithSmoothingsGroups()</b> (<i>SmoothingGroups.h</i>) - Computes normal vectors from plain old smoothing groups. </li>
+<li><b>SkeletonMeshBuilder</b> (<i>SkeletonMeshBuilder.h</i>) - generate a dummy mesh from a given (animation) skeleton. </li>
+<li><b>StandardShapes</b> (<i>StandardShapes.h</i>) - generate meshes for standard solids, such as platonic primitives, cylinders or spheres. </li>
+<li><b>BatchLoader</b> (<i>BaseImporter.h</i>) - manage imports from external files. Useful for file formats
+which spread their data across multiple files. </li>
+<li><b>SceneCombiner</b> (<i>SceneCombiner.h</i>) - exhaustive toolset to merge multiple scenes. Useful for file formats
+which spread their data across multiple files. </li>
+</ul>
+
+@section mat Filling materials
+
+The required definitions zo set/remove/query keys in #aiMaterial structures are declared in <i>MaterialSystem.h</i>, in a
+#aiMaterial derivate called #aiMaterial. The header is included by AssimpPCH.h, so you don't need to bother.
+
+@code
+aiMaterial* mat = new aiMaterial();
+
+const float spec = 16.f;
+mat->AddProperty(&spec, 1, AI_MATKEY_SHININESS);
+
+//set the name of the material:
+NewMaterial->AddProperty(&aiString(MaterialName.c_str()), AI_MATKEY_NAME);//MaterialName is a std::string
+
+//set the first diffuse texture
+NewMaterial->AddProperty(&aiString(Texturename.c_str()), AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));//again, Texturename is a std::string
+@endcode
+
+@section boost Boost
+
+The boost whitelist:
+<ul>
+<li><i>boost.scoped_ptr</i></li>
+<li><i>boost.scoped_array</i></li>
+<li><i>boost.format</i> </li>
+<li><i>boost.random</i> </li>
+<li><i>boost.common_factor</i> </li>
+<li><i>boost.foreach</i> </li>
+<li><i>boost.tuple</i></li>
+</ul>
+
+(if you happen to need something else, i.e. boost::thread, make this an optional feature.
+<tt>assimp_BUILD_BOOST_WORKAROUND</tt> is defined for <i>-noboost</i> builds)
+
+@section appa Appendix A - Template for BaseImporter's abstract methods
+
+@code
+// -------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool xxxxImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler,
+	bool checkSig) const
+{
+	const std::string extension = GetExtension(pFile);
+	if(extension == "xxxx") {
+		return true;
+	}
+	if (!extension.length() || checkSig) {
+		// no extension given, or we're called a second time because no
+		// suitable loader was found yet. This means, we're trying to open
+		// the file and look for and hints to identify the file format.
+		// #Assimp::BaseImporter provides some utilities:
+		//
+		// #Assimp::BaseImporter::SearchFileHeaderForToken - for text files.
+		// It reads the first lines of the file and does a substring check
+		// against a given list of 'magic' strings.
+		//
+		// #Assimp::BaseImporter::CheckMagicToken - for binary files. It goes
+		// to a particular offset in the file and and compares the next words
+		// against a given list of 'magic' tokens.
+
+		// These checks MUST be done (even if !checkSig) if the file extension
+		// is not exclusive to your format. For example, .xml is very common
+		// and (co)used by many formats.
+	}
+	return false;
+}
+
+// -------------------------------------------------------------------------------
+// Get list of file extensions handled by this loader
+void xxxxImporter::GetExtensionList(std::set<std::string>& extensions)
+{
+	extensions.insert("xxx");
+}
+
+// -------------------------------------------------------------------------------
+void xxxxImporter::InternReadFile( const std::string& pFile,
+	aiScene* pScene, IOSystem* pIOHandler)
+{
+	boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+
+	// Check whether we can read from the file
+	if( file.get() == NULL) {
+		throw DeadlyImportError( "Failed to open xxxx file " + pFile + ".");
+	}
+
+	// Your task: fill pScene
+	// Throw a ImportErrorException with a meaningful (!) error message if
+	// something goes wrong.
+}
+
+@endcode
+ */
+
+
+ /**
+ @page AnimationOverview Animation Overview
+ \section Transformations
+ This diagram shows how you can calculate your transformationmatrices for an animated character:
+ <img src="AnimationOverview.png" />
+
+ **/

samples/SimpleOpenGL/Sample_SimpleOpenGL.c

@@ -1,389 +1,389 @@
-/* ----------------------------------------------------------------------------
-// Simple sample to prove that Assimp is easy to use with OpenGL.
-// It takes a file name as command line parameter, loads it using standard
-// settings and displays it.
-//
-// If you intend to _use_ this code sample in your app, do yourself a favour 
-// and replace immediate mode calls with VBOs ...
-//
-// The vc8 solution links against assimp-release-dll_win32 - be sure to
-// have this configuration built.
-// ----------------------------------------------------------------------------
-*/
-
-#include <stdlib.h>
-#include <stdio.h>
-
-#ifdef __APPLE__
-#include <glut.h>
-#else
-#include <GL/glut.h>
-#endif
-
-/* assimp include files. These three are usually needed. */
-#include <assimp/cimport.h>
-#include <assimp/scene.h>
-#include <assimp/postprocess.h>
-
-/* the global Assimp scene object */
-const struct aiScene* scene = NULL;
-GLuint scene_list = 0;
-struct aiVector3D scene_min, scene_max, scene_center;
-
-/* current rotation angle */
-static float angle = 0.f;
-
-#define aisgl_min(x,y) (x<y?x:y)
-#define aisgl_max(x,y) (y>x?y:x)
-
-/* ---------------------------------------------------------------------------- */
-void reshape(int width, int height)
-{
-	const double aspectRatio = (float) width / height, fieldOfView = 45.0;
-
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-	gluPerspective(fieldOfView, aspectRatio,
-		1.0, 1000.0);  /* Znear and Zfar */
-	glViewport(0, 0, width, height);
-}
-
-/* ---------------------------------------------------------------------------- */
-void get_bounding_box_for_node (const struct aiNode* nd, 
-	struct aiVector3D* min, 
-	struct aiVector3D* max, 
-	struct aiMatrix4x4* trafo
-){
-	struct aiMatrix4x4 prev;
-	unsigned int n = 0, t;
-
-	prev = *trafo;
-	aiMultiplyMatrix4(trafo,&nd->mTransformation);
-
-	for (; n < nd->mNumMeshes; ++n) {
-		const struct aiMesh* mesh = scene->mMeshes[nd->mMeshes[n]];
-		for (t = 0; t < mesh->mNumVertices; ++t) {
-
-			struct aiVector3D tmp = mesh->mVertices[t];
-			aiTransformVecByMatrix4(&tmp,trafo);
-
-			min->x = aisgl_min(min->x,tmp.x);
-			min->y = aisgl_min(min->y,tmp.y);
-			min->z = aisgl_min(min->z,tmp.z);
-
-			max->x = aisgl_max(max->x,tmp.x);
-			max->y = aisgl_max(max->y,tmp.y);
-			max->z = aisgl_max(max->z,tmp.z);
-		}
-	}
-
-	for (n = 0; n < nd->mNumChildren; ++n) {
-		get_bounding_box_for_node(nd->mChildren[n],min,max,trafo);
-	}
-	*trafo = prev;
-}
-
-/* ---------------------------------------------------------------------------- */
-void get_bounding_box (struct aiVector3D* min, struct aiVector3D* max)
-{
-	struct aiMatrix4x4 trafo;
-	aiIdentityMatrix4(&trafo);
-
-	min->x = min->y = min->z =  1e10f;
-	max->x = max->y = max->z = -1e10f;
-	get_bounding_box_for_node(scene->mRootNode,min,max,&trafo);
-}
-
-/* ---------------------------------------------------------------------------- */
-void color4_to_float4(const struct aiColor4D *c, float f[4])
-{
-	f[0] = c->r;
-	f[1] = c->g;
-	f[2] = c->b;
-	f[3] = c->a;
-}
-
-/* ---------------------------------------------------------------------------- */
-void set_float4(float f[4], float a, float b, float c, float d)
-{
-	f[0] = a;
-	f[1] = b;
-	f[2] = c;
-	f[3] = d;
-}
-
-/* ---------------------------------------------------------------------------- */
-void apply_material(const struct aiMaterial *mtl)
-{
-	float c[4];
-
-	GLenum fill_mode;
-	int ret1, ret2;
-	struct aiColor4D diffuse;
-	struct aiColor4D specular;
-	struct aiColor4D ambient;
-	struct aiColor4D emission;
-	float shininess, strength;
-	int two_sided;
-	int wireframe;
-	unsigned int max;
-
-	set_float4(c, 0.8f, 0.8f, 0.8f, 1.0f);
-	if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_DIFFUSE, &diffuse))
-		color4_to_float4(&diffuse, c);
-	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, c);
-
-	set_float4(c, 0.0f, 0.0f, 0.0f, 1.0f);
-	if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_SPECULAR, &specular))
-		color4_to_float4(&specular, c);
-	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c);
-
-	set_float4(c, 0.2f, 0.2f, 0.2f, 1.0f);
-	if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_AMBIENT, &ambient))
-		color4_to_float4(&ambient, c);
-	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, c);
-
-	set_float4(c, 0.0f, 0.0f, 0.0f, 1.0f);
-	if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_EMISSIVE, &emission))
-		color4_to_float4(&emission, c);
-	glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, c);
-
-	max = 1;
-	ret1 = aiGetMaterialFloatArray(mtl, AI_MATKEY_SHININESS, &shininess, &max);
-	if(ret1 == AI_SUCCESS) {
-    	max = 1;
-    	ret2 = aiGetMaterialFloatArray(mtl, AI_MATKEY_SHININESS_STRENGTH, &strength, &max);
-		if(ret2 == AI_SUCCESS)
-			glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess * strength);
-        else
-        	glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
-    }
-	else {
-		glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0f);
-		set_float4(c, 0.0f, 0.0f, 0.0f, 0.0f);
-		glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c);
-	}
-
-	max = 1;
-	if(AI_SUCCESS == aiGetMaterialIntegerArray(mtl, AI_MATKEY_ENABLE_WIREFRAME, &wireframe, &max))
-		fill_mode = wireframe ? GL_LINE : GL_FILL;
-	else
-		fill_mode = GL_FILL;
-	glPolygonMode(GL_FRONT_AND_BACK, fill_mode);
-
-	max = 1;
-	if((AI_SUCCESS == aiGetMaterialIntegerArray(mtl, AI_MATKEY_TWOSIDED, &two_sided, &max)) && two_sided)
-		glDisable(GL_CULL_FACE);
-	else 
-		glEnable(GL_CULL_FACE);
-}
-
-/* ---------------------------------------------------------------------------- */
-void recursive_render (const struct aiScene *sc, const struct aiNode* nd)
-{
-	unsigned int i;
-	unsigned int n = 0, t;
-	struct aiMatrix4x4 m = nd->mTransformation;
-
-	/* update transform */
-	aiTransposeMatrix4(&m);
-	glPushMatrix();
-	glMultMatrixf((float*)&m);
-
-	/* draw all meshes assigned to this node */
-	for (; n < nd->mNumMeshes; ++n) {
-		const struct aiMesh* mesh = scene->mMeshes[nd->mMeshes[n]];
-
-		apply_material(sc->mMaterials[mesh->mMaterialIndex]);
-
-		if(mesh->mNormals == NULL) {
-			glDisable(GL_LIGHTING);
-		} else {
-			glEnable(GL_LIGHTING);
-		}
-
-		for (t = 0; t < mesh->mNumFaces; ++t) {
-			const struct aiFace* face = &mesh->mFaces[t];
-			GLenum face_mode;
-
-			switch(face->mNumIndices) {
-				case 1: face_mode = GL_POINTS; break;
-				case 2: face_mode = GL_LINES; break;
-				case 3: face_mode = GL_TRIANGLES; break;
-				default: face_mode = GL_POLYGON; break;
-			}
-
-			glBegin(face_mode);
-
-			for(i = 0; i < face->mNumIndices; i++) {
-				int index = face->mIndices[i];
-				if(mesh->mColors[0] != NULL)
-					glColor4fv((GLfloat*)&mesh->mColors[0][index]);
-				if(mesh->mNormals != NULL) 
-					glNormal3fv(&mesh->mNormals[index].x);
-				glVertex3fv(&mesh->mVertices[index].x);
-			}
-
-			glEnd();
-		}
-
-	}
-
-	/* draw all children */
-	for (n = 0; n < nd->mNumChildren; ++n) {
-		recursive_render(sc, nd->mChildren[n]);
-	}
-
-	glPopMatrix();
-}
-
-/* ---------------------------------------------------------------------------- */
-void do_motion (void)
-{
-	static GLint prev_time = 0;
-	static GLint prev_fps_time = 0;
-	static int frames = 0;
-
-	int time = glutGet(GLUT_ELAPSED_TIME);
-	angle += (time-prev_time)*0.01;
-	prev_time = time;
-
-	frames += 1;
-	if ((time - prev_fps_time) > 1000) /* update every seconds */
-    {
-        int current_fps = frames * 1000 / (time - prev_fps_time);
-        printf("%d fps\n", current_fps);
-        frames = 0;
-        prev_fps_time = time;
-    }
-
-
-	glutPostRedisplay ();
-}
-
-/* ---------------------------------------------------------------------------- */
-void display(void)
-{
-	float tmp;
-
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
-	glMatrixMode(GL_MODELVIEW);
-	glLoadIdentity();
-	gluLookAt(0.f,0.f,3.f,0.f,0.f,-5.f,0.f,1.f,0.f);
-
-	/* rotate it around the y axis */
-	glRotatef(angle,0.f,1.f,0.f);
-
-	/* scale the whole asset to fit into our view frustum */
-	tmp = scene_max.x-scene_min.x;
-	tmp = aisgl_max(scene_max.y - scene_min.y,tmp);
-	tmp = aisgl_max(scene_max.z - scene_min.z,tmp);
-	tmp = 1.f / tmp;
-	glScalef(tmp, tmp, tmp);
-
-        /* center the model */
-	glTranslatef( -scene_center.x, -scene_center.y, -scene_center.z );
-
-        /* if the display list has not been made yet, create a new one and
-           fill it with scene contents */
-	if(scene_list == 0) {
-	    scene_list = glGenLists(1);
-	    glNewList(scene_list, GL_COMPILE);
-            /* now begin at the root node of the imported data and traverse
-               the scenegraph by multiplying subsequent local transforms
-               together on GL's matrix stack. */
-	    recursive_render(scene, scene->mRootNode);
-	    glEndList();
-	}
-
-	glCallList(scene_list);
-
-	glutSwapBuffers();
-
-	do_motion();
-}
-
-/* ---------------------------------------------------------------------------- */
-int loadasset (const char* path)
-{
-	/* we are taking one of the postprocessing presets to avoid
-	   spelling out 20+ single postprocessing flags here. */
-	scene = aiImportFile(path,aiProcessPreset_TargetRealtime_MaxQuality);
-
-	if (scene) {
-		get_bounding_box(&scene_min,&scene_max);
-		scene_center.x = (scene_min.x + scene_max.x) / 2.0f;
-		scene_center.y = (scene_min.y + scene_max.y) / 2.0f;
-		scene_center.z = (scene_min.z + scene_max.z) / 2.0f;
-		return 0;
-	}
-	return 1;
-}
-
-/* ---------------------------------------------------------------------------- */
-int main(int argc, char **argv)
-{
-	struct aiLogStream stream;
-
-	glutInitWindowSize(900,600);
-	glutInitWindowPosition(100,100);
-	glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
-	glutInit(&argc, argv);
-
-	glutCreateWindow("Assimp - Very simple OpenGL sample");
-	glutDisplayFunc(display);
-	glutReshapeFunc(reshape);
-
-	/* get a handle to the predefined STDOUT log stream and attach
-	   it to the logging system. It remains active for all further
-	   calls to aiImportFile(Ex) and aiApplyPostProcessing. */
-	stream = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT,NULL);
-	aiAttachLogStream(&stream);
-
-	/* ... same procedure, but this stream now writes the
-	   log messages to assimp_log.txt */
-	stream = aiGetPredefinedLogStream(aiDefaultLogStream_FILE,"assimp_log.txt");
-	aiAttachLogStream(&stream);
-
-	/* the model name can be specified on the command line. If none
-	  is specified, we try to locate one of the more expressive test 
-	  models from the repository (/models-nonbsd may be missing in 
-	  some distributions so we need a fallback from /models!). */
-	if( 0 != loadasset( argc >= 2 ? argv[1] : "../../test/models-nonbsd/X/dwarf.x")) {
-		if( argc != 1 || (0 != loadasset( "../../../../test/models-nonbsd/X/dwarf.x") && 0 != loadasset( "../../test/models/X/Testwuson.X"))) { 
-			return -1;
-		}
-	}
-
-	glClearColor(0.1f,0.1f,0.1f,1.f);
-
-	glEnable(GL_LIGHTING);
-	glEnable(GL_LIGHT0);    /* Uses default lighting parameters */
-
-	glEnable(GL_DEPTH_TEST);
-
-	glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
-	glEnable(GL_NORMALIZE);
-
-	/* XXX docs say all polygons are emitted CCW, but tests show that some aren't. */
-	if(getenv("MODEL_IS_BROKEN"))  
-		glFrontFace(GL_CW);
-
-	glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
-
-	glutGet(GLUT_ELAPSED_TIME);
-	glutMainLoop();
-
-	/* cleanup - calling 'aiReleaseImport' is important, as the library 
-	   keeps internal resources until the scene is freed again. Not 
-	   doing so can cause severe resource leaking. */
-	aiReleaseImport(scene);
-
-	/* We added a log stream to the library, it's our job to disable it
-	   again. This will definitely release the last resources allocated
-	   by Assimp.*/
-	aiDetachAllLogStreams();
-	return 0;
-}
-
+/* ----------------------------------------------------------------------------
+// Simple sample to prove that Assimp is easy to use with OpenGL.
+// It takes a file name as command line parameter, loads it using standard
+// settings and displays it.
+//
+// If you intend to _use_ this code sample in your app, do yourself a favour 
+// and replace immediate mode calls with VBOs ...
+//
+// The vc8 solution links against assimp-release-dll_win32 - be sure to
+// have this configuration built.
+// ----------------------------------------------------------------------------
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef __APPLE__
+#include <glut.h>
+#else
+#include <GL/glut.h>
+#endif
+
+/* assimp include files. These three are usually needed. */
+#include <assimp/cimport.h>
+#include <assimp/scene.h>
+#include <assimp/postprocess.h>
+
+/* the global Assimp scene object */
+const struct aiScene* scene = NULL;
+GLuint scene_list = 0;
+struct aiVector3D scene_min, scene_max, scene_center;
+
+/* current rotation angle */
+static float angle = 0.f;
+
+#define aisgl_min(x,y) (x<y?x:y)
+#define aisgl_max(x,y) (y>x?y:x)
+
+/* ---------------------------------------------------------------------------- */
+void reshape(int width, int height)
+{
+	const double aspectRatio = (float) width / height, fieldOfView = 45.0;
+
+	glMatrixMode(GL_PROJECTION);
+	glLoadIdentity();
+	gluPerspective(fieldOfView, aspectRatio,
+		1.0, 1000.0);  /* Znear and Zfar */
+	glViewport(0, 0, width, height);
+}
+
+/* ---------------------------------------------------------------------------- */
+void get_bounding_box_for_node (const struct aiNode* nd, 
+	struct aiVector3D* min, 
+	struct aiVector3D* max, 
+	struct aiMatrix4x4* trafo
+){
+	struct aiMatrix4x4 prev;
+	unsigned int n = 0, t;
+
+	prev = *trafo;
+	aiMultiplyMatrix4(trafo,&nd->mTransformation);
+
+	for (; n < nd->mNumMeshes; ++n) {
+		const struct aiMesh* mesh = scene->mMeshes[nd->mMeshes[n]];
+		for (t = 0; t < mesh->mNumVertices; ++t) {
+
+			struct aiVector3D tmp = mesh->mVertices[t];
+			aiTransformVecByMatrix4(&tmp,trafo);
+
+			min->x = aisgl_min(min->x,tmp.x);
+			min->y = aisgl_min(min->y,tmp.y);
+			min->z = aisgl_min(min->z,tmp.z);
+
+			max->x = aisgl_max(max->x,tmp.x);
+			max->y = aisgl_max(max->y,tmp.y);
+			max->z = aisgl_max(max->z,tmp.z);
+		}
+	}
+
+	for (n = 0; n < nd->mNumChildren; ++n) {
+		get_bounding_box_for_node(nd->mChildren[n],min,max,trafo);
+	}
+	*trafo = prev;
+}
+
+/* ---------------------------------------------------------------------------- */
+void get_bounding_box (struct aiVector3D* min, struct aiVector3D* max)
+{
+	struct aiMatrix4x4 trafo;
+	aiIdentityMatrix4(&trafo);
+
+	min->x = min->y = min->z =  1e10f;
+	max->x = max->y = max->z = -1e10f;
+	get_bounding_box_for_node(scene->mRootNode,min,max,&trafo);
+}
+
+/* ---------------------------------------------------------------------------- */
+void color4_to_float4(const struct aiColor4D *c, float f[4])
+{
+	f[0] = c->r;
+	f[1] = c->g;
+	f[2] = c->b;
+	f[3] = c->a;
+}
+
+/* ---------------------------------------------------------------------------- */
+void set_float4(float f[4], float a, float b, float c, float d)
+{
+	f[0] = a;
+	f[1] = b;
+	f[2] = c;
+	f[3] = d;
+}
+
+/* ---------------------------------------------------------------------------- */
+void apply_material(const struct aiMaterial *mtl)
+{
+	float c[4];
+
+	GLenum fill_mode;
+	int ret1, ret2;
+	struct aiColor4D diffuse;
+	struct aiColor4D specular;
+	struct aiColor4D ambient;
+	struct aiColor4D emission;
+	float shininess, strength;
+	int two_sided;
+	int wireframe;
+	unsigned int max;
+
+	set_float4(c, 0.8f, 0.8f, 0.8f, 1.0f);
+	if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_DIFFUSE, &diffuse))
+		color4_to_float4(&diffuse, c);
+	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, c);
+
+	set_float4(c, 0.0f, 0.0f, 0.0f, 1.0f);
+	if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_SPECULAR, &specular))
+		color4_to_float4(&specular, c);
+	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c);
+
+	set_float4(c, 0.2f, 0.2f, 0.2f, 1.0f);
+	if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_AMBIENT, &ambient))
+		color4_to_float4(&ambient, c);
+	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, c);
+
+	set_float4(c, 0.0f, 0.0f, 0.0f, 1.0f);
+	if(AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_EMISSIVE, &emission))
+		color4_to_float4(&emission, c);
+	glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, c);
+
+	max = 1;
+	ret1 = aiGetMaterialFloatArray(mtl, AI_MATKEY_SHININESS, &shininess, &max);
+	if(ret1 == AI_SUCCESS) {
+    	max = 1;
+    	ret2 = aiGetMaterialFloatArray(mtl, AI_MATKEY_SHININESS_STRENGTH, &strength, &max);
+		if(ret2 == AI_SUCCESS)
+			glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess * strength);
+        else
+        	glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
+    }
+	else {
+		glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.0f);
+		set_float4(c, 0.0f, 0.0f, 0.0f, 0.0f);
+		glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, c);
+	}
+
+	max = 1;
+	if(AI_SUCCESS == aiGetMaterialIntegerArray(mtl, AI_MATKEY_ENABLE_WIREFRAME, &wireframe, &max))
+		fill_mode = wireframe ? GL_LINE : GL_FILL;
+	else
+		fill_mode = GL_FILL;
+	glPolygonMode(GL_FRONT_AND_BACK, fill_mode);
+
+	max = 1;
+	if((AI_SUCCESS == aiGetMaterialIntegerArray(mtl, AI_MATKEY_TWOSIDED, &two_sided, &max)) && two_sided)
+		glDisable(GL_CULL_FACE);
+	else 
+		glEnable(GL_CULL_FACE);
+}
+
+/* ---------------------------------------------------------------------------- */
+void recursive_render (const struct aiScene *sc, const struct aiNode* nd)
+{
+	unsigned int i;
+	unsigned int n = 0, t;
+	struct aiMatrix4x4 m = nd->mTransformation;
+
+	/* update transform */
+	aiTransposeMatrix4(&m);
+	glPushMatrix();
+	glMultMatrixf((float*)&m);
+
+	/* draw all meshes assigned to this node */
+	for (; n < nd->mNumMeshes; ++n) {
+		const struct aiMesh* mesh = scene->mMeshes[nd->mMeshes[n]];
+
+		apply_material(sc->mMaterials[mesh->mMaterialIndex]);
+
+		if(mesh->mNormals == NULL) {
+			glDisable(GL_LIGHTING);
+		} else {
+			glEnable(GL_LIGHTING);
+		}
+
+		for (t = 0; t < mesh->mNumFaces; ++t) {
+			const struct aiFace* face = &mesh->mFaces[t];
+			GLenum face_mode;
+
+			switch(face->mNumIndices) {
+				case 1: face_mode = GL_POINTS; break;
+				case 2: face_mode = GL_LINES; break;
+				case 3: face_mode = GL_TRIANGLES; break;
+				default: face_mode = GL_POLYGON; break;
+			}
+
+			glBegin(face_mode);
+
+			for(i = 0; i < face->mNumIndices; i++) {
+				int index = face->mIndices[i];
+				if(mesh->mColors[0] != NULL)
+					glColor4fv((GLfloat*)&mesh->mColors[0][index]);
+				if(mesh->mNormals != NULL) 
+					glNormal3fv(&mesh->mNormals[index].x);
+				glVertex3fv(&mesh->mVertices[index].x);
+			}
+
+			glEnd();
+		}
+
+	}
+
+	/* draw all children */
+	for (n = 0; n < nd->mNumChildren; ++n) {
+		recursive_render(sc, nd->mChildren[n]);
+	}
+
+	glPopMatrix();
+}
+
+/* ---------------------------------------------------------------------------- */
+void do_motion (void)
+{
+	static GLint prev_time = 0;
+	static GLint prev_fps_time = 0;
+	static int frames = 0;
+
+	int time = glutGet(GLUT_ELAPSED_TIME);
+	angle += (time-prev_time)*0.01;
+	prev_time = time;
+
+	frames += 1;
+	if ((time - prev_fps_time) > 1000) /* update every seconds */
+    {
+        int current_fps = frames * 1000 / (time - prev_fps_time);
+        printf("%d fps\n", current_fps);
+        frames = 0;
+        prev_fps_time = time;
+    }
+
+
+	glutPostRedisplay ();
+}
+
+/* ---------------------------------------------------------------------------- */
+void display(void)
+{
+	float tmp;
+
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+	glMatrixMode(GL_MODELVIEW);
+	glLoadIdentity();
+	gluLookAt(0.f,0.f,3.f,0.f,0.f,-5.f,0.f,1.f,0.f);
+
+	/* rotate it around the y axis */
+	glRotatef(angle,0.f,1.f,0.f);
+
+	/* scale the whole asset to fit into our view frustum */
+	tmp = scene_max.x-scene_min.x;
+	tmp = aisgl_max(scene_max.y - scene_min.y,tmp);
+	tmp = aisgl_max(scene_max.z - scene_min.z,tmp);
+	tmp = 1.f / tmp;
+	glScalef(tmp, tmp, tmp);
+
+        /* center the model */
+	glTranslatef( -scene_center.x, -scene_center.y, -scene_center.z );
+
+        /* if the display list has not been made yet, create a new one and
+           fill it with scene contents */
+	if(scene_list == 0) {
+	    scene_list = glGenLists(1);
+	    glNewList(scene_list, GL_COMPILE);
+            /* now begin at the root node of the imported data and traverse
+               the scenegraph by multiplying subsequent local transforms
+               together on GL's matrix stack. */
+	    recursive_render(scene, scene->mRootNode);
+	    glEndList();
+	}
+
+	glCallList(scene_list);
+
+	glutSwapBuffers();
+
+	do_motion();
+}
+
+/* ---------------------------------------------------------------------------- */
+int loadasset (const char* path)
+{
+	/* we are taking one of the postprocessing presets to avoid
+	   spelling out 20+ single postprocessing flags here. */
+	scene = aiImportFile(path,aiProcessPreset_TargetRealtime_MaxQuality);
+
+	if (scene) {
+		get_bounding_box(&scene_min,&scene_max);
+		scene_center.x = (scene_min.x + scene_max.x) / 2.0f;
+		scene_center.y = (scene_min.y + scene_max.y) / 2.0f;
+		scene_center.z = (scene_min.z + scene_max.z) / 2.0f;
+		return 0;
+	}
+	return 1;
+}
+
+/* ---------------------------------------------------------------------------- */
+int main(int argc, char **argv)
+{
+	struct aiLogStream stream;
+
+	glutInitWindowSize(900,600);
+	glutInitWindowPosition(100,100);
+	glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
+	glutInit(&argc, argv);
+
+	glutCreateWindow("Assimp - Very simple OpenGL sample");
+	glutDisplayFunc(display);
+	glutReshapeFunc(reshape);
+
+	/* get a handle to the predefined STDOUT log stream and attach
+	   it to the logging system. It remains active for all further
+	   calls to aiImportFile(Ex) and aiApplyPostProcessing. */
+	stream = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT,NULL);
+	aiAttachLogStream(&stream);
+
+	/* ... same procedure, but this stream now writes the
+	   log messages to assimp_log.txt */
+	stream = aiGetPredefinedLogStream(aiDefaultLogStream_FILE,"assimp_log.txt");
+	aiAttachLogStream(&stream);
+
+	/* the model name can be specified on the command line. If none
+	  is specified, we try to locate one of the more expressive test 
+	  models from the repository (/models-nonbsd may be missing in 
+	  some distributions so we need a fallback from /models!). */
+	if( 0 != loadasset( argc >= 2 ? argv[1] : "../../test/models-nonbsd/X/dwarf.x")) {
+		if( argc != 1 || (0 != loadasset( "../../../../test/models-nonbsd/X/dwarf.x") && 0 != loadasset( "../../test/models/X/Testwuson.X"))) { 
+			return -1;
+		}
+	}
+
+	glClearColor(0.1f,0.1f,0.1f,1.f);
+
+	glEnable(GL_LIGHTING);
+	glEnable(GL_LIGHT0);    /* Uses default lighting parameters */
+
+	glEnable(GL_DEPTH_TEST);
+
+	glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
+	glEnable(GL_NORMALIZE);
+
+	/* XXX docs say all polygons are emitted CCW, but tests show that some aren't. */
+	if(getenv("MODEL_IS_BROKEN"))  
+		glFrontFace(GL_CW);
+
+	glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
+
+	glutGet(GLUT_ELAPSED_TIME);
+	glutMainLoop();
+
+	/* cleanup - calling 'aiReleaseImport' is important, as the library 
+	   keeps internal resources until the scene is freed again. Not 
+	   doing so can cause severe resource leaking. */
+	aiReleaseImport(scene);
+
+	/* We added a log stream to the library, it's our job to disable it
+	   again. This will definitely release the last resources allocated
+	   by Assimp.*/
+	aiDetachAllLogStreams();
+	return 0;
+}
+

scripts/IFCImporter/entitylist.txt

@@ -1,111 +1,111 @@
-# ==============================================================================
-# List of IFC structures needed by Assimp
-# ==============================================================================
-# use genentitylist.sh to update this list
-
-# This machine-generated list is not complete, it lacks many intermediate
-# classes in the inheritance hierarchy. Those are magically augmented by the
-# code generator. Also, the names of all used entities need to be present
-# in the source code for this to work.
-
-IfcAnnotation
-IfcArbitraryClosedProfileDef
-IfcArbitraryOpenProfileDef
-IfcArbitraryProfileDefWithVoids
-IfcAxis1Placement
-IfcAxis2Placement
-IfcAxis2Placement2D
-IfcAxis2Placement3D
-IfcBooleanClippingResult
-IfcBooleanResult
-IfcBoundedCurve
-IfcBoundingBox
-IfcBSplineCurve
-IfcBuilding
-IfcCartesianPoint
-IfcCartesianTransformationOperator
-IfcCartesianTransformationOperator3D
-IfcCartesianTransformationOperator3DnonUniform
-IfcCircle
-IfcCircleHollowProfileDef
-IfcCircleProfileDef
-IfcClosedShell
-IfcColourOrFactor
-IfcColourRgb
-IfcCompositeCurve
-IfcCompositeCurveSegment
-IfcConic
-IfcConnectedFaceSet
-IfcConversionBasedUnit
-IfcCurve
-IfcDirection
-IfcDoor
-IfcEllipse
-IfcExtrudedAreaSolid
-IfcFace
-IfcFaceBasedSurfaceModel
-IfcFaceBound
-IfcFaceOuterBound
-IfcFeatureElementSubtraction
-IfcGeometricRepresentationContext
-IfcGeometricRepresentationItem
-IfcHalfSpaceSolid
-IfcLine
-IfcLocalPlacement
-IfcManifoldSolidBrep
-IfcMappedItem
-IfcMeasureWithUnit
-IfcNamedUnit
-IfcObjectDefinition
-IfcObjectPlacement
-IfcOpeningElement
-IfcParameterizedProfileDef
-IfcPlane
-IfcPolygonalBoundedHalfSpace
-IfcPolyline
-IfcPolyLoop
-IfcPresentationStyleAssignment
-IfcPresentationStyleSelect
-IfcProduct
-IfcProductRepresentation
-IfcProfileDef
-IfcProject
-IfcRectangleProfileDef
-IfcRelAggregates
-IfcRelContainedInSpatialStructure
-IfcRelFillsElement
-IfcRelVoidsElement
-IfcRepresentation
-IfcRepresentationContext
-IfcRepresentationItem
-IfcRepresentationMap
-IfcRevolvedAreaSolid
-IfcShell
-IfcShellBasedSurfaceModel
-IfcSite
-IfcSIUnit
-IfcSomething
-IfcSpace
-IfcSpatialStructureElement
-IfcSpatialStructureElements
-IfcStyledItem
-IfcSurfaceStyle
-IfcSurfaceStyleElementSelect
-IfcSurfaceStyleRendering
-IfcSurfaceStyleShading
-IfcSurfaceStyleWithTextures
-IfcSweptAreaSolid
-IfcSweptDiskSolid
-IfcTopologicalRepresentationItem
-IfcTrimmedCurve
-IfcUnit
-IfcUnitAssignment
-IfcVector
-IfcIShapeProfileDef
-IfcPropertyListValue
-IfcRelDefinesByProperties
-IfcPropertySet
-IfcPropertySingleValue
-IfcProperty
-IfcComplexProperty
-IfcElementQuantity
+# ==============================================================================
+# List of IFC structures needed by Assimp
+# ==============================================================================
+# use genentitylist.sh to update this list
+
+# This machine-generated list is not complete, it lacks many intermediate
+# classes in the inheritance hierarchy. Those are magically augmented by the
+# code generator. Also, the names of all used entities need to be present
+# in the source code for this to work.
+
+IfcAnnotation
+IfcArbitraryClosedProfileDef
+IfcArbitraryOpenProfileDef
+IfcArbitraryProfileDefWithVoids
+IfcAxis1Placement
+IfcAxis2Placement
+IfcAxis2Placement2D
+IfcAxis2Placement3D
+IfcBooleanClippingResult
+IfcBooleanResult
+IfcBoundedCurve
+IfcBoundingBox
+IfcBSplineCurve
+IfcBuilding
+IfcCartesianPoint
+IfcCartesianTransformationOperator
+IfcCartesianTransformationOperator3D
+IfcCartesianTransformationOperator3DnonUniform
+IfcCircle
+IfcCircleHollowProfileDef
+IfcCircleProfileDef
+IfcClosedShell
+IfcColourOrFactor
+IfcColourRgb
+IfcCompositeCurve
+IfcCompositeCurveSegment
+IfcConic
+IfcConnectedFaceSet
+IfcConversionBasedUnit
+IfcCurve
+IfcDirection
+IfcDoor
+IfcEllipse
+IfcExtrudedAreaSolid
+IfcFace
+IfcFaceBasedSurfaceModel
+IfcFaceBound
+IfcFaceOuterBound
+IfcFeatureElementSubtraction
+IfcGeometricRepresentationContext
+IfcGeometricRepresentationItem
+IfcHalfSpaceSolid
+IfcLine
+IfcLocalPlacement
+IfcManifoldSolidBrep
+IfcMappedItem
+IfcMeasureWithUnit
+IfcNamedUnit
+IfcObjectDefinition
+IfcObjectPlacement
+IfcOpeningElement
+IfcParameterizedProfileDef
+IfcPlane
+IfcPolygonalBoundedHalfSpace
+IfcPolyline
+IfcPolyLoop
+IfcPresentationStyleAssignment
+IfcPresentationStyleSelect
+IfcProduct
+IfcProductRepresentation
+IfcProfileDef
+IfcProject
+IfcRectangleProfileDef
+IfcRelAggregates
+IfcRelContainedInSpatialStructure
+IfcRelFillsElement
+IfcRelVoidsElement
+IfcRepresentation
+IfcRepresentationContext
+IfcRepresentationItem
+IfcRepresentationMap
+IfcRevolvedAreaSolid
+IfcShell
+IfcShellBasedSurfaceModel
+IfcSite
+IfcSIUnit
+IfcSomething
+IfcSpace
+IfcSpatialStructureElement
+IfcSpatialStructureElements
+IfcStyledItem
+IfcSurfaceStyle
+IfcSurfaceStyleElementSelect
+IfcSurfaceStyleRendering
+IfcSurfaceStyleShading
+IfcSurfaceStyleWithTextures
+IfcSweptAreaSolid
+IfcSweptDiskSolid
+IfcTopologicalRepresentationItem
+IfcTrimmedCurve
+IfcUnit
+IfcUnitAssignment
+IfcVector
+IfcIShapeProfileDef
+IfcPropertyListValue
+IfcRelDefinesByProperties
+IfcPropertySet
+IfcPropertySingleValue
+IfcProperty
+IfcComplexProperty
+IfcElementQuantity

workspaces/xcode6/Assimp.xcodeproj/project.pbxproj

@@ -0,0 +1,1980 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		7F79242A1AB43E20005A8E5D /* 3DSConverter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 15221A74FC9C4B2AAA7306E3 /* 3DSConverter.cpp */; };
+		7F79242B1AB43E20005A8E5D /* 3DSExporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = ECCBBF2D75A44335AB93C84A /* 3DSExporter.cpp */; };
+		7F79242C1AB43E20005A8E5D /* 3DSLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 02E9476D129940BF84DE6682 /* 3DSLoader.cpp */; };
+		7F79242D1AB43E20005A8E5D /* ACLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F1076BAC69DB4935A93045A8 /* ACLoader.cpp */; };
+		7F79242E1AB43E20005A8E5D /* ASELoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7C477FA4D89548F1BCEDC5A0 /* ASELoader.cpp */; };
+		7F79242F1AB43E20005A8E5D /* ASEParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 929F59CCA32549EC884A5033 /* ASEParser.cpp */; };
+		7F7924301AB43E20005A8E5D /* AssbinExporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6389F68312384CFD847B1D13 /* AssbinExporter.cpp */; };
+		7F7924311AB43E20005A8E5D /* AssbinLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D9FEEF58B24548F782A5D53C /* AssbinLoader.cpp */; };
+		7F7924321AB43E20005A8E5D /* Assimp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 705D30EE141A48F292783F0E /* Assimp.cpp */; };
+		7F7924331AB43E20005A8E5D /* AssimpCExport.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A1A9535EDF9A4FF2B8DABD7D /* AssimpCExport.cpp */; };
+		7F7924351AB43E20005A8E5D /* AssxmlExporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B3E8A1BEF8E74F04AE06871B /* AssxmlExporter.cpp */; };
+		7F7924361AB43E20005A8E5D /* B3DImporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FCCB4BB481FB461688FE2F29 /* B3DImporter.cpp */; };
+		7F7924371AB43E20005A8E5D /* BVHLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C80B9A3AF4204AE08AA50BAE /* BVHLoader.cpp */; };
+		7F7924381AB43E20005A8E5D /* BaseImporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A58410FEAA884A2D8D73ACCE /* BaseImporter.cpp */; };
+		7F7924391AB43E20005A8E5D /* BaseProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FAB6BC13FCFE40F5801D0972 /* BaseProcess.cpp */; };
+		7F79243A1AB43E20005A8E5D /* Bitmap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 10238FBD7A9D401A82D667CB /* Bitmap.cpp */; };
+		7F79243B1AB43E20005A8E5D /* BlenderBMesh.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 603AFA882AFF49AEAC2C8FA2 /* BlenderBMesh.cpp */; };
+		7F79243C1AB43E20005A8E5D /* BlenderDNA.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B65258E349704523BC43904D /* BlenderDNA.cpp */; };
+		7F79243D1AB43E20005A8E5D /* BlenderLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 906F71D342544BF381E1318E /* BlenderLoader.cpp */; };
+		7F79243E1AB43E20005A8E5D /* BlenderModifier.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3106D75C13874F5AB3EBBFE7 /* BlenderModifier.cpp */; };
+		7F79243F1AB43E20005A8E5D /* BlenderScene.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DE0D259917354C80BE1CC791 /* BlenderScene.cpp */; };
+		7F7924401AB43E20005A8E5D /* BlenderTessellator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 12C5DD7A285042EDB1897FAE /* BlenderTessellator.cpp */; };
+		7F7924411AB43E20005A8E5D /* COBLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C84DA0E6CE13493D833BA1C1 /* COBLoader.cpp */; };
+		7F7924421AB43E20005A8E5D /* CSMLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 77908990BEF04D0881E8AE80 /* CSMLoader.cpp */; };
+		7F7924431AB43E20005A8E5D /* CalcTangentsProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 90DD6CA40A5E41458E11FF3E /* CalcTangentsProcess.cpp */; };
+		7F7924441AB43E20005A8E5D /* ColladaExporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1C0527629078403F81CFD117 /* ColladaExporter.cpp */; };
+		7F7924451AB43E20005A8E5D /* ColladaLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1A4706D216414D4F8AA72EC9 /* ColladaLoader.cpp */; };
+		7F7924461AB43E20005A8E5D /* ColladaParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 420D77ED33554D54AA4D50EF /* ColladaParser.cpp */; };
+		7F7924471AB43E20005A8E5D /* ComputeUVMappingProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2ABBB4561E72413EB40702C3 /* ComputeUVMappingProcess.cpp */; };
+		7F7924481AB43E20005A8E5D /* ConvertToLHProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 92D8734FFF9742B39A371B70 /* ConvertToLHProcess.cpp */; };
+		7F7924491AB43E20005A8E5D /* DXFLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 466D6B9A7CCD402D9AA87071 /* DXFLoader.cpp */; };
+		7F79244A1AB43E20005A8E5D /* DeboneProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6E20FCC571F144DDBD831CCB /* DeboneProcess.cpp */; };
+		7F79244B1AB43E20005A8E5D /* DefaultIOStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F9FEF4D69EFC4605A4F752E5 /* DefaultIOStream.cpp */; };
+		7F79244C1AB43E20005A8E5D /* DefaultIOSystem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1D502654EF864101A2DA9476 /* DefaultIOSystem.cpp */; };
+		7F79244D1AB43E20005A8E5D /* DefaultLogger.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A9E9EB834E09420197C3FB8C /* DefaultLogger.cpp */; };
+		7F79244E1AB43E20005A8E5D /* Exporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FF4E90FB1A3446F095ECC8BD /* Exporter.cpp */; };
+		7F79244F1AB43E20005A8E5D /* FBXAnimation.cpp in Sources */ = {isa = PBXBuildFile; fileRef = EAD34F1AA6664B6B935C9421 /* FBXAnimation.cpp */; };
+		7F7924501AB43E20005A8E5D /* FBXBinaryTokenizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1108AC28566B4D2B9F27C691 /* FBXBinaryTokenizer.cpp */; };
+		7F7924511AB43E20005A8E5D /* FBXConverter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A7A56A688A3845768410F500 /* FBXConverter.cpp */; };
+		7F7924521AB43E20005A8E5D /* FBXDeformer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9855496CEA774F4FA7FBB862 /* FBXDeformer.cpp */; };
+		7F7924531AB43E20005A8E5D /* FBXDocument.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F22D5BA425444A028DA42BEA /* FBXDocument.cpp */; };
+		7F7924541AB43E20005A8E5D /* FBXDocumentUtil.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BB38E7E7661842448F008372 /* FBXDocumentUtil.cpp */; };
+		7F7924551AB43E20005A8E5D /* FBXImporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B4C688FA08F44716855CDD3C /* FBXImporter.cpp */; };
+		7F7924561AB43E20005A8E5D /* FBXMaterial.cpp in Sources */ = {isa = PBXBuildFile; fileRef = EE6163EB035149A6B8139DB8 /* FBXMaterial.cpp */; };
+		7F7924571AB43E20005A8E5D /* FBXMeshGeometry.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 42E110B9E6924AF9B55AE65A /* FBXMeshGeometry.cpp */; };
+		7F7924581AB43E20005A8E5D /* FBXModel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1A61BDC559CE4186B03C0396 /* FBXModel.cpp */; };
+		7F7924591AB43E20005A8E5D /* FBXNodeAttribute.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 33B70115CA54405F895BA471 /* FBXNodeAttribute.cpp */; };
+		7F79245A1AB43E20005A8E5D /* FBXParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5F373DF3B03B4B848B78EAD2 /* FBXParser.cpp */; };
+		7F79245B1AB43E20005A8E5D /* FBXProperties.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9D203F78B24C4D7E8E2084A3 /* FBXProperties.cpp */; };
+		7F79245C1AB43E20005A8E5D /* FBXTokenizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CF07D05DC86F4C98BC42FDCF /* FBXTokenizer.cpp */; };
+		7F79245D1AB43E20005A8E5D /* FBXUtil.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E6332CD992D447CA910DA456 /* FBXUtil.cpp */; };
+		7F79245E1AB43E20005A8E5D /* FindDegenerates.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BABB7734139C452A9DDEE797 /* FindDegenerates.cpp */; };
+		7F79245F1AB43E20005A8E5D /* FindInstancesProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C9A101D1311C4E77AAEDD94C /* FindInstancesProcess.cpp */; };
+		7F7924601AB43E20005A8E5D /* FindInvalidDataProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9B4221AA0AD2418FAA45EB64 /* FindInvalidDataProcess.cpp */; };
+		7F7924611AB43E20005A8E5D /* FixNormalsStep.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C54518F708BA4A328D5D7325 /* FixNormalsStep.cpp */; };
+		7F7924621AB43E20005A8E5D /* GenFaceNormalsProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 982AE676D2364350B1FBD095 /* GenFaceNormalsProcess.cpp */; };
+		7F7924631AB43E20005A8E5D /* GenVertexNormalsProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A0AED12A1A6D4635A8CFB65A /* GenVertexNormalsProcess.cpp */; };
+		7F7924641AB43E20005A8E5D /* HMPLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 43ABFF591F374920A5E18A24 /* HMPLoader.cpp */; };
+		7F7924651AB43E20005A8E5D /* IFCBoolean.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 285D1FDA48EC4DD8933B603E /* IFCBoolean.cpp */; };
+		7F7924661AB43E20005A8E5D /* IFCCurve.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2E7FD92FFCF441B0A60FC8B4 /* IFCCurve.cpp */; };
+		7F7924671AB43E20005A8E5D /* IFCGeometry.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3267EBBA6EEB435F83FF25E4 /* IFCGeometry.cpp */; };
+		7F7924681AB43E20005A8E5D /* IFCLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D0E9BB0220704C5D93CE7CE9 /* IFCLoader.cpp */; };
+		7F7924691AB43E20005A8E5D /* IFCMaterial.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0014AE5E87A74AAA9EF0EC4B /* IFCMaterial.cpp */; };
+		7F79246A1AB43E20005A8E5D /* IFCOpenings.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 74679D2078FD46ED9AC73355 /* IFCOpenings.cpp */; };
+		7F79246B1AB43E20005A8E5D /* IFCProfile.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 46E9F455A3284DB399986293 /* IFCProfile.cpp */; };
+		7F79246C1AB43E20005A8E5D /* IFCReaderGen.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3F5D1E6368384D429BA29D5A /* IFCReaderGen.cpp */; };
+		7F79246D1AB43E20005A8E5D /* IFCUtil.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 59E3D32E3FC7438DB148537F /* IFCUtil.cpp */; };
+		7F79246E1AB43E20005A8E5D /* IRRLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97DFA90F9D0C4B999C150B10 /* IRRLoader.cpp */; };
+		7F79246F1AB43E20005A8E5D /* IRRMeshLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DD7FFD53046F4AEB898C0832 /* IRRMeshLoader.cpp */; };
+		7F7924701AB43E20005A8E5D /* IRRShared.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CC54A231FF6B4B0CABCFD167 /* IRRShared.cpp */; };
+		7F7924711AB43E20005A8E5D /* Importer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9472EFB6831740DD91471337 /* Importer.cpp */; };
+		7F7924721AB43E20005A8E5D /* ImporterRegistry.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D029CE902F8045B0B3AFFDDB /* ImporterRegistry.cpp */; };
+		7F7924731AB43E20005A8E5D /* ImproveCacheLocality.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 70D5FDFA995E45E6A3E8FD37 /* ImproveCacheLocality.cpp */; };
+		7F7924741AB43E20005A8E5D /* JoinVerticesProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B36DA471B9E142FC9425EC45 /* JoinVerticesProcess.cpp */; };
+		7F7924751AB43E20005A8E5D /* LWOAnimation.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 680C392FFE0B4CC5ABC7CA64 /* LWOAnimation.cpp */; };
+		7F7924761AB43E20005A8E5D /* LWOBLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D629F6BF53864979B7619067 /* LWOBLoader.cpp */; };
+		7F7924771AB43E20005A8E5D /* LWOLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5A4E05386C094B809A315A07 /* LWOLoader.cpp */; };
+		7F7924781AB43E20005A8E5D /* LWOMaterial.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1ED21FC57A384CE6B4F53C0C /* LWOMaterial.cpp */; };
+		7F7924791AB43E20005A8E5D /* LWSLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AFF41974881F466A9561BE4B /* LWSLoader.cpp */; };
+		7F79247A1AB43E20005A8E5D /* LimitBoneWeightsProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E065DB38B0284196A9283CA3 /* LimitBoneWeightsProcess.cpp */; };
+		7F79247B1AB43E20005A8E5D /* MD2Loader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 49B655CCE1314D4E8A94B371 /* MD2Loader.cpp */; };
+		7F79247C1AB43E20005A8E5D /* MD3Loader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 563FBACCFD774BDEA4AEAC10 /* MD3Loader.cpp */; };
+		7F79247D1AB43E20005A8E5D /* MD5Loader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A277DBC1EFB944F995659A20 /* MD5Loader.cpp */; };
+		7F79247E1AB43E20005A8E5D /* MD5Parser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0BC5FD00572F4C58B267A0EC /* MD5Parser.cpp */; };
+		7F79247F1AB43E20005A8E5D /* MDCLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 35E4944C052A4C91BF31DE5F /* MDCLoader.cpp */; };
+		7F7924801AB43E20005A8E5D /* MDLLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AA92FFC8B06D4569AD9C4CB1 /* MDLLoader.cpp */; };
+		7F7924811AB43E20005A8E5D /* MDLMaterialLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CEC69808E1844C23B95D3475 /* MDLMaterialLoader.cpp */; };
+		7F7924821AB43E20005A8E5D /* MS3DLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A7A990C6FF244DC397B7BA7C /* MS3DLoader.cpp */; };
+		7F7924831AB43E20005A8E5D /* MakeVerboseFormat.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21B797DAB0E0427C9339AE0F /* MakeVerboseFormat.cpp */; };
+		7F7924841AB43E20005A8E5D /* MaterialSystem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7FF72CB6E99E40E19AE0E64C /* MaterialSystem.cpp */; };
+		7F7924851AB43E20005A8E5D /* NDOLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B4F1B5789CA540C78FB9219D /* NDOLoader.cpp */; };
+		7F7924861AB43E20005A8E5D /* NFFLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0D6E8E292F594A2DAFF53564 /* NFFLoader.cpp */; };
+		7F7924871AB43E20005A8E5D /* OFFLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = EFD557FE2C3A46D78F070655 /* OFFLoader.cpp */; };
+		7F7924881AB43E20005A8E5D /* ObjExporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DE811A81663A492A84E13937 /* ObjExporter.cpp */; };
+		7F7924891AB43E20005A8E5D /* ObjFileImporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 862131D4574B4CABA5EC957B /* ObjFileImporter.cpp */; };
+		7F79248A1AB43E20005A8E5D /* ObjFileMtlImporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4108529663904025B21E526B /* ObjFileMtlImporter.cpp */; };
+		7F79248B1AB43E20005A8E5D /* ObjFileParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = ACF73EEAB2424213BF7158D5 /* ObjFileParser.cpp */; };
+		7F79248C1AB43E20005A8E5D /* OgreBinarySerializer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 56ADEC4899C047F2839AD791 /* OgreBinarySerializer.cpp */; };
+		7F79248D1AB43E20005A8E5D /* OgreImporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 923283A9791E4B4E86D623FC /* OgreImporter.cpp */; };
+		7F79248E1AB43E20005A8E5D /* OgreMaterial.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F75457C6D026451B9267B65E /* OgreMaterial.cpp */; };
+		7F79248F1AB43E20005A8E5D /* OgreStructs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 79A49EFE23E34E1CBA2E4377 /* OgreStructs.cpp */; };
+		7F7924901AB43E20005A8E5D /* OgreXmlSerializer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = EF9F805A4BA4428CA98C9DE5 /* OgreXmlSerializer.cpp */; };
+		7F7924911AB43E20005A8E5D /* OptimizeGraph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AAB9AE5328F843F5A8A3E85C /* OptimizeGraph.cpp */; };
+		7F7924921AB43E20005A8E5D /* OptimizeMeshes.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2ACC87E846AE4E4A86E1AEF4 /* OptimizeMeshes.cpp */; };
+		7F7924931AB43E20005A8E5D /* PlyExporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E51043448F1744FFA78526D5 /* PlyExporter.cpp */; };
+		7F7924941AB43E20005A8E5D /* PlyLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 409C98EE093C499B8A574CA9 /* PlyLoader.cpp */; };
+		7F7924951AB43E20005A8E5D /* PlyParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2C4D504725E540109530E254 /* PlyParser.cpp */; };
+		7F7924961AB43E20005A8E5D /* PostStepRegistry.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E663847651834244834CB9F5 /* PostStepRegistry.cpp */; };
+		7F7924971AB43E20005A8E5D /* PretransformVertices.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 023C115651B54570AA2040DB /* PretransformVertices.cpp */; };
+		7F7924981AB43E20005A8E5D /* ProcessHelper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 890E32C714444692AA016AE5 /* ProcessHelper.cpp */; };
+		7F7924991AB43E20005A8E5D /* Q3BSPFileImporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A88D56FBEA084A3EA9A0ECB3 /* Q3BSPFileImporter.cpp */; };
+		7F79249A1AB43E20005A8E5D /* Q3BSPFileParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4A60A00727F04E049CF3AE33 /* Q3BSPFileParser.cpp */; };
+		7F79249B1AB43E20005A8E5D /* Q3BSPZipArchive.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 43C75175738C4119871E8BB0 /* Q3BSPZipArchive.cpp */; };
+		7F79249C1AB43E20005A8E5D /* Q3DLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C5178B3983F147F3B9BD8217 /* Q3DLoader.cpp */; };
+		7F79249D1AB43E20005A8E5D /* RawLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1D4A669762194B9D9A26DD20 /* RawLoader.cpp */; };
+		7F79249E1AB43E20005A8E5D /* RemoveComments.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6A86069DEEDC42B88634F78D /* RemoveComments.cpp */; };
+		7F79249F1AB43E20005A8E5D /* RemoveRedundantMaterials.cpp in Sources */ = {isa = PBXBuildFile; fileRef = ADACEBC4973F4FC0A6FEC68A /* RemoveRedundantMaterials.cpp */; };
+		7F7924A01AB43E20005A8E5D /* RemoveVCProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FB4ABA17AF264257BDA4D921 /* RemoveVCProcess.cpp */; };
+		7F7924A11AB43E20005A8E5D /* SGSpatialSort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 52836A0629E24447B924750A /* SGSpatialSort.cpp */; };
+		7F7924A21AB43E20005A8E5D /* SMDLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FD9BEC6B8A264AB092F98E20 /* SMDLoader.cpp */; };
+		7F7924A31AB43E20005A8E5D /* STEPFileEncoding.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E11A39E91576445599DF2AC4 /* STEPFileEncoding.cpp */; };
+		7F7924A41AB43E20005A8E5D /* STEPFileReader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CDE3ECA98173418A9F997992 /* STEPFileReader.cpp */; };
+		7F7924A51AB43E20005A8E5D /* STLExporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 89D2D359BD854D8AA60CB720 /* STLExporter.cpp */; };
+		7F7924A61AB43E20005A8E5D /* STLLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4D2F1605B9484B08BB33402D /* STLLoader.cpp */; };
+		7F7924A71AB43E20005A8E5D /* SceneCombiner.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 73A3D87FF2C04C3BA3684F54 /* SceneCombiner.cpp */; };
+		7F7924A81AB43E20005A8E5D /* ScenePreprocessor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1775DE08FC8647EB896A0FB3 /* ScenePreprocessor.cpp */; };
+		7F7924A91AB43E20005A8E5D /* SkeletonMeshBuilder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9B2827B3E64147E08A5AD334 /* SkeletonMeshBuilder.cpp */; };
+		7F7924AA1AB43E20005A8E5D /* SortByPTypeProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BD9A81E0E27E44718609615B /* SortByPTypeProcess.cpp */; };
+		7F7924AB1AB43E20005A8E5D /* SpatialSort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8EEC6646FC044D1E9658A590 /* SpatialSort.cpp */; };
+		7F7924AC1AB43E20005A8E5D /* SplitByBoneCountProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 99A4349D505F4CC593F48CF6 /* SplitByBoneCountProcess.cpp */; };
+		7F7924AD1AB43E20005A8E5D /* SplitLargeMeshes.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A43641DC9C1B4B578BC40476 /* SplitLargeMeshes.cpp */; };
+		7F7924AE1AB43E20005A8E5D /* StandardShapes.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C18C5023460E4D17B8C922D7 /* StandardShapes.cpp */; };
+		7F7924AF1AB43E20005A8E5D /* Subdivision.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BBDEB63CFEB4F2EAA95358D /* Subdivision.cpp */; };
+		7F7924B01AB43E20005A8E5D /* TargetAnimation.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6F65B6129F774AEDB8DC845A /* TargetAnimation.cpp */; };
+		7F7924B11AB43E20005A8E5D /* TerragenLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4866DA5A7BFD49F79B61CBF8 /* TerragenLoader.cpp */; };
+		7F7924B21AB43E20005A8E5D /* TextureTransform.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DF76D04D95E649BCBC15E64F /* TextureTransform.cpp */; };
+		7F7924B31AB43E20005A8E5D /* TriangulateProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1A0AC303D18A48A69AB3BC03 /* TriangulateProcess.cpp */; };
+		7F7924B41AB43E20005A8E5D /* UnrealLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3B8FD96D46314ACD8F157AC3 /* UnrealLoader.cpp */; };
+		7F7924B51AB43E20005A8E5D /* ValidateDataStructure.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0EF4F7A237F648C2809A8F31 /* ValidateDataStructure.cpp */; };
+		7F7924B61AB43E20005A8E5D /* VertexTriangleAdjacency.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0AAF26EBF0A64ABDB840BA64 /* VertexTriangleAdjacency.cpp */; };
+		7F7924B71AB43E20005A8E5D /* XFileExporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 435DC362E63D4CCBA68656D3 /* XFileExporter.cpp */; };
+		7F7924B81AB43E20005A8E5D /* XFileImporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 06DB494DCE4D47FDA00E8B35 /* XFileImporter.cpp */; };
+		7F7924B91AB43E20005A8E5D /* XFileParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 74C02A113B804568A7E39CBC /* XFileParser.cpp */; };
+		7F7924BA1AB43E20005A8E5D /* XGLLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8E395349546A4FDF843E6963 /* XGLLoader.cpp */; };
+		7F7924BB1AB43E20005A8E5D /* ConvertUTF.c in Sources */ = {isa = PBXBuildFile; fileRef = 9A0960F123634603B15EEA38 /* ConvertUTF.c */; };
+		7F7924BC1AB43E20005A8E5D /* clipper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 59F8A11A7AED45CC94CEDF28 /* clipper.cpp */; };
+		7F7924BD1AB43E20005A8E5D /* irrXML.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 64C6BACDA5DD4139AA26EE81 /* irrXML.cpp */; };
+		7F7924BE1AB43E20005A8E5D /* shapes.cc in Sources */ = {isa = PBXBuildFile; fileRef = AE00939F150F413780C8AAD7 /* shapes.cc */; };
+		7F7924BF1AB43E20005A8E5D /* advancing_front.cc in Sources */ = {isa = PBXBuildFile; fileRef = B72D0BA3EF66439F8D582ED3 /* advancing_front.cc */; };
+		7F7924C01AB43E20005A8E5D /* cdt.cc in Sources */ = {isa = PBXBuildFile; fileRef = 849EC6315E4A4E5FA06521EA /* cdt.cc */; };
+		7F7924C11AB43E20005A8E5D /* sweep.cc in Sources */ = {isa = PBXBuildFile; fileRef = 49E993CD86A346869AF473BC /* sweep.cc */; };
+		7F7924C21AB43E20005A8E5D /* sweep_context.cc in Sources */ = {isa = PBXBuildFile; fileRef = 5E10483FBE6D4F4594B460E0 /* sweep_context.cc */; };
+		7F7924C31AB43E20005A8E5D /* ioapi.c in Sources */ = {isa = PBXBuildFile; fileRef = AF75E6049338489BB256D295 /* ioapi.c */; };
+		7F7924C41AB43E20005A8E5D /* unzip.c in Sources */ = {isa = PBXBuildFile; fileRef = 973D4231A4AA4925B019FEEE /* unzip.c */; };
+		7F7A93A81B65D0110094C4DA /* DDLNode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7F7A93A51B65D0110094C4DA /* DDLNode.cpp */; };
+		7F7A93A91B65D0110094C4DA /* OpenDDLParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7F7A93A61B65D0110094C4DA /* OpenDDLParser.cpp */; };
+		7F7A93AA1B65D0110094C4DA /* Value.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7F7A93A71B65D0110094C4DA /* Value.cpp */; };
+		7FBE9FEA1B65AC1200D2115E /* OpenGEXExporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7FBE9FE51B65AC1200D2115E /* OpenGEXExporter.cpp */; };
+		7FBE9FEB1B65AC1200D2115E /* OpenGEXImporter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7FBE9FE71B65AC1200D2115E /* OpenGEXImporter.cpp */; };
+		7FBEA0121B65B11800D2115E /* Version.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7FBEA0111B65B11800D2115E /* Version.cpp */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		0014AE5E87A74AAA9EF0EC4B /* IFCMaterial.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = IFCMaterial.cpp; path = code/IFCMaterial.cpp; sourceTree = SOURCE_ROOT; };
+		005DFE3B6FFC4BEBB7055330 /* ObjFileData.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ObjFileData.h; path = code/ObjFileData.h; sourceTree = SOURCE_ROOT; };
+		00EB692107B84590B0560BFB /* MD4FileData.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MD4FileData.h; path = code/MD4FileData.h; sourceTree = SOURCE_ROOT; };
+		023C115651B54570AA2040DB /* PretransformVertices.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = PretransformVertices.cpp; path = code/PretransformVertices.cpp; sourceTree = SOURCE_ROOT; };
+		02587469A85540EE875B04B5 /* heapsort.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = heapsort.h; path = contrib/irrXML/heapsort.h; sourceTree = SOURCE_ROOT; };
+		02E9476D129940BF84DE6682 /* 3DSLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = 3DSLoader.cpp; path = code/3DSLoader.cpp; sourceTree = SOURCE_ROOT; };
+		0535CB113239433DA7CD7FDE /* color4.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = color4.h; path = include/assimp/color4.h; sourceTree = SOURCE_ROOT; };
+		05EA73C462244F1791039BFB /* material.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = material.h; path = include/assimp/material.h; sourceTree = SOURCE_ROOT; };
+		06DB494DCE4D47FDA00E8B35 /* XFileImporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = XFileImporter.cpp; path = code/XFileImporter.cpp; sourceTree = SOURCE_ROOT; };
+		073189BEE7A5466B9EE817D4 /* matrix3x3.inl */ = {isa = PBXFileReference; explicitFileType = sourcecode; fileEncoding = 4; name = matrix3x3.inl; path = include/assimp/matrix3x3.inl; sourceTree = SOURCE_ROOT; };
+		079B3C75D1014265959C427D /* color4.inl */ = {isa = PBXFileReference; explicitFileType = sourcecode; fileEncoding = 4; name = color4.inl; path = include/assimp/color4.inl; sourceTree = SOURCE_ROOT; };
+		08E8379F20984AD59515AD95 /* MD3FileData.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MD3FileData.h; path = code/MD3FileData.h; sourceTree = SOURCE_ROOT; };
+		0A941971CBF04E8D900E9799 /* JoinVerticesProcess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = JoinVerticesProcess.h; path = code/JoinVerticesProcess.h; sourceTree = SOURCE_ROOT; };
+		0AA53AD6095A4D1088431EED /* MakeVerboseFormat.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MakeVerboseFormat.h; path = code/MakeVerboseFormat.h; sourceTree = SOURCE_ROOT; };
+		0AAF26EBF0A64ABDB840BA64 /* VertexTriangleAdjacency.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = VertexTriangleAdjacency.cpp; path = code/VertexTriangleAdjacency.cpp; sourceTree = SOURCE_ROOT; };
+		0B519CCAB4B241E59C567077 /* 3DSExporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = 3DSExporter.h; path = code/3DSExporter.h; sourceTree = SOURCE_ROOT; };
+		0BC5FD00572F4C58B267A0EC /* MD5Parser.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = MD5Parser.cpp; path = code/MD5Parser.cpp; sourceTree = SOURCE_ROOT; };
+		0C1B00249A554394A4F9CF2A /* ParsingUtils.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ParsingUtils.h; path = code/ParsingUtils.h; sourceTree = SOURCE_ROOT; };
+		0CCD090F58EB40ACBBDBBDEE /* AssbinLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = AssbinLoader.h; path = code/AssbinLoader.h; sourceTree = SOURCE_ROOT; };
+		0D6E8E292F594A2DAFF53564 /* NFFLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = NFFLoader.cpp; path = code/NFFLoader.cpp; sourceTree = SOURCE_ROOT; };
+		0EF256EC06E345EB930772EC /* FBXDocument.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = FBXDocument.h; path = code/FBXDocument.h; sourceTree = SOURCE_ROOT; };
+		0EF4F7A237F648C2809A8F31 /* ValidateDataStructure.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ValidateDataStructure.cpp; path = code/ValidateDataStructure.cpp; sourceTree = SOURCE_ROOT; };
+		0FBF026F27F340AD9FABAF02 /* GenFaceNormalsProcess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = GenFaceNormalsProcess.h; path = code/GenFaceNormalsProcess.h; sourceTree = SOURCE_ROOT; };
+		101172E4EF2E43D988B6B571 /* PretransformVertices.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = PretransformVertices.h; path = code/PretransformVertices.h; sourceTree = SOURCE_ROOT; };
+		1011FC45108745A7BBA98904 /* IRRLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = IRRLoader.h; path = code/IRRLoader.h; sourceTree = SOURCE_ROOT; };
+		10238FBD7A9D401A82D667CB /* Bitmap.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = Bitmap.cpp; path = code/Bitmap.cpp; sourceTree = SOURCE_ROOT; };
+		10E9B0497D844A10BC759A09 /* matrix3x3.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = matrix3x3.h; path = include/assimp/matrix3x3.h; sourceTree = SOURCE_ROOT; };
+		1108AC28566B4D2B9F27C691 /* FBXBinaryTokenizer.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FBXBinaryTokenizer.cpp; path = code/FBXBinaryTokenizer.cpp; sourceTree = SOURCE_ROOT; };
+		12C5DD7A285042EDB1897FAE /* BlenderTessellator.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = BlenderTessellator.cpp; path = code/BlenderTessellator.cpp; sourceTree = SOURCE_ROOT; };
+		12E167EBA81B4CD3A241D7AF /* irrXML.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = irrXML.h; path = contrib/irrXML/irrXML.h; sourceTree = SOURCE_ROOT; };
+		139DFC029C4C44B09952C645 /* material.inl */ = {isa = PBXFileReference; explicitFileType = sourcecode; fileEncoding = 4; name = material.inl; path = include/assimp/material.inl; sourceTree = SOURCE_ROOT; };
+		13BFADA520C04B15AE256CC2 /* IFCUtil.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = IFCUtil.h; path = code/IFCUtil.h; sourceTree = SOURCE_ROOT; };
+		1520A11AA6E54812939B1FBB /* FileLogStream.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = FileLogStream.h; path = code/FileLogStream.h; sourceTree = SOURCE_ROOT; };
+		15221A74FC9C4B2AAA7306E3 /* 3DSConverter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = 3DSConverter.cpp; path = code/3DSConverter.cpp; sourceTree = SOURCE_ROOT; };
+		1533BE4C09F1430C8BF4D248 /* Vertex.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = Vertex.h; path = code/Vertex.h; sourceTree = SOURCE_ROOT; };
+		157C3CC81232428FA535E05F /* BlenderLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = BlenderLoader.h; path = code/BlenderLoader.h; sourceTree = SOURCE_ROOT; };
+		16437E08A946431EB2EFA3E0 /* SortByPTypeProcess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = SortByPTypeProcess.h; path = code/SortByPTypeProcess.h; sourceTree = SOURCE_ROOT; };
+		1775DE08FC8647EB896A0FB3 /* ScenePreprocessor.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ScenePreprocessor.cpp; path = code/ScenePreprocessor.cpp; sourceTree = SOURCE_ROOT; };
+		180177D50FDA4C10AD629DC2 /* ObjFileMtlImporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ObjFileMtlImporter.h; path = code/ObjFileMtlImporter.h; sourceTree = SOURCE_ROOT; };
+		1A0AC303D18A48A69AB3BC03 /* TriangulateProcess.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = TriangulateProcess.cpp; path = code/TriangulateProcess.cpp; sourceTree = SOURCE_ROOT; };
+		1A4706D216414D4F8AA72EC9 /* ColladaLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ColladaLoader.cpp; path = code/ColladaLoader.cpp; sourceTree = SOURCE_ROOT; };
+		1A61BDC559CE4186B03C0396 /* FBXModel.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FBXModel.cpp; path = code/FBXModel.cpp; sourceTree = SOURCE_ROOT; };
+		1AF1EE8EFE594A40ACE03D19 /* fast_atof.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = fast_atof.h; path = code/fast_atof.h; sourceTree = SOURCE_ROOT; };
+		1BC6B0FE92DD4F38803BC17B /* CSMLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = CSMLoader.h; path = code/CSMLoader.h; sourceTree = SOURCE_ROOT; };
+		1C0527629078403F81CFD117 /* ColladaExporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ColladaExporter.cpp; path = code/ColladaExporter.cpp; sourceTree = SOURCE_ROOT; };
+		1CBCEE37D89145F19F23F036 /* MD3Loader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MD3Loader.h; path = code/MD3Loader.h; sourceTree = SOURCE_ROOT; };
+		1D4A669762194B9D9A26DD20 /* RawLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = RawLoader.cpp; path = code/RawLoader.cpp; sourceTree = SOURCE_ROOT; };
+		1D502654EF864101A2DA9476 /* DefaultIOSystem.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = DefaultIOSystem.cpp; path = code/DefaultIOSystem.cpp; sourceTree = SOURCE_ROOT; };
+		1DC56C794E434BA28E5CCC36 /* format.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = format.hpp; path = code/BoostWorkaround/boost/format.hpp; sourceTree = SOURCE_ROOT; };
+		1ED21FC57A384CE6B4F53C0C /* LWOMaterial.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = LWOMaterial.cpp; path = code/LWOMaterial.cpp; sourceTree = SOURCE_ROOT; };
+		1FC965B1F11B45F98051C565 /* ObjFileImporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ObjFileImporter.h; path = code/ObjFileImporter.h; sourceTree = SOURCE_ROOT; };
+		21B797DAB0E0427C9339AE0F /* MakeVerboseFormat.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = MakeVerboseFormat.cpp; path = code/MakeVerboseFormat.cpp; sourceTree = SOURCE_ROOT; };
+		21E21BE7CB364AC3AB81E54C /* MD2FileData.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MD2FileData.h; path = code/MD2FileData.h; sourceTree = SOURCE_ROOT; };
+		23097CBD64E343738B8F22EE /* BlobIOSystem.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = BlobIOSystem.h; path = code/BlobIOSystem.h; sourceTree = SOURCE_ROOT; };
+		262DFE65C6D34442AA79D15A /* qnan.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = qnan.h; path = code/qnan.h; sourceTree = SOURCE_ROOT; };
+		267A74499024423A86150697 /* cimport.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = cimport.h; path = include/assimp/cimport.h; sourceTree = SOURCE_ROOT; };
+		267D593135514108B7DEF072 /* sweep_context.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = sweep_context.h; path = contrib/poly2tri/poly2tri/sweep/sweep_context.h; sourceTree = SOURCE_ROOT; };
+		26BF681530B04B73961997CB /* FBXCompileConfig.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = FBXCompileConfig.h; path = code/FBXCompileConfig.h; sourceTree = SOURCE_ROOT; };
+		27605E75944D41B0B98260A3 /* ASEParser.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ASEParser.h; path = code/ASEParser.h; sourceTree = SOURCE_ROOT; };
+		278FB5C8BD814F2DAE04A1C7 /* pstdint.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = pstdint.h; path = include/assimp/Compiler/pstdint.h; sourceTree = SOURCE_ROOT; };
+		279D2A482FE9402A8F7EC441 /* quaternion.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = quaternion.h; path = include/assimp/quaternion.h; sourceTree = SOURCE_ROOT; };
+		27F2019E621B4CDA94DD5270 /* UnrealLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = UnrealLoader.h; path = code/UnrealLoader.h; sourceTree = SOURCE_ROOT; };
+		285D1FDA48EC4DD8933B603E /* IFCBoolean.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = IFCBoolean.cpp; path = code/IFCBoolean.cpp; sourceTree = SOURCE_ROOT; };
+		28A938B21261484998F68F4A /* FindInstancesProcess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = FindInstancesProcess.h; path = code/FindInstancesProcess.h; sourceTree = SOURCE_ROOT; };
+		296407DE471C4F298742FB59 /* StandardShapes.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = StandardShapes.h; path = code/StandardShapes.h; sourceTree = SOURCE_ROOT; };
+		2ABBB4561E72413EB40702C3 /* ComputeUVMappingProcess.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ComputeUVMappingProcess.cpp; path = code/ComputeUVMappingProcess.cpp; sourceTree = SOURCE_ROOT; };
+		2AC344FBB0C34D49800F4B8A /* GenVertexNormalsProcess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = GenVertexNormalsProcess.h; path = code/GenVertexNormalsProcess.h; sourceTree = SOURCE_ROOT; };
+		2ACC87E846AE4E4A86E1AEF4 /* OptimizeMeshes.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = OptimizeMeshes.cpp; path = code/OptimizeMeshes.cpp; sourceTree = SOURCE_ROOT; };
+		2BE34AF1CE0C4767ACE21597 /* IFCLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = IFCLoader.h; path = code/IFCLoader.h; sourceTree = SOURCE_ROOT; };
+		2C4D504725E540109530E254 /* PlyParser.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = PlyParser.cpp; path = code/PlyParser.cpp; sourceTree = SOURCE_ROOT; };
+		2DCF6F156A3A4B4C807E5368 /* SmoothingGroups.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = SmoothingGroups.h; path = code/SmoothingGroups.h; sourceTree = SOURCE_ROOT; };
+		2E7FD92FFCF441B0A60FC8B4 /* IFCCurve.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = IFCCurve.cpp; path = code/IFCCurve.cpp; sourceTree = SOURCE_ROOT; };
+		2F34A6A3C4104625A52BF7C2 /* cexport.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = cexport.h; path = include/assimp/cexport.h; sourceTree = SOURCE_ROOT; };
+		3106D75C13874F5AB3EBBFE7 /* BlenderModifier.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = BlenderModifier.cpp; path = code/BlenderModifier.cpp; sourceTree = SOURCE_ROOT; };
+		32170F499DAC4E4595AF6D6B /* BaseImporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = BaseImporter.h; path = code/BaseImporter.h; sourceTree = SOURCE_ROOT; };
+		3267EBBA6EEB435F83FF25E4 /* IFCGeometry.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = IFCGeometry.cpp; path = code/IFCGeometry.cpp; sourceTree = SOURCE_ROOT; };
+		32CC68350B7640ACA7C83DDA /* DefaultIOStream.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = DefaultIOStream.h; path = code/DefaultIOStream.h; sourceTree = SOURCE_ROOT; };
+		333F4676A92043739F5A9D32 /* ObjFileParser.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ObjFileParser.h; path = code/ObjFileParser.h; sourceTree = SOURCE_ROOT; };
+		339E56B5FD264481BBF21835 /* CInterfaceIOWrapper.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = CInterfaceIOWrapper.h; path = code/CInterfaceIOWrapper.h; sourceTree = SOURCE_ROOT; };
+		33B70115CA54405F895BA471 /* FBXNodeAttribute.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FBXNodeAttribute.cpp; path = code/FBXNodeAttribute.cpp; sourceTree = SOURCE_ROOT; };
+		3551D90CCED1454A8B912066 /* XFileParser.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = XFileParser.h; path = code/XFileParser.h; sourceTree = SOURCE_ROOT; };
+		35A9B50143214C63A956FA27 /* ConvertToLHProcess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ConvertToLHProcess.h; path = code/ConvertToLHProcess.h; sourceTree = SOURCE_ROOT; };
+		35E4944C052A4C91BF31DE5F /* MDCLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = MDCLoader.cpp; path = code/MDCLoader.cpp; sourceTree = SOURCE_ROOT; };
+		37A3E0E2BB484DD8B9FCCA5E /* NDOLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = NDOLoader.h; path = code/NDOLoader.h; sourceTree = SOURCE_ROOT; };
+		3ACFF3FC39C74C4A966C0FEA /* GenericProperty.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = GenericProperty.h; path = code/GenericProperty.h; sourceTree = SOURCE_ROOT; };
+		3B407EAF162843CBA46BC9D4 /* scene.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = scene.h; path = include/assimp/scene.h; sourceTree = SOURCE_ROOT; };
+		3B8FD96D46314ACD8F157AC3 /* UnrealLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = UnrealLoader.cpp; path = code/UnrealLoader.cpp; sourceTree = SOURCE_ROOT; };
+		3E84DEFC1E0646AD82F79998 /* shared_ptr.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = shared_ptr.hpp; path = code/BoostWorkaround/boost/shared_ptr.hpp; sourceTree = SOURCE_ROOT; };
+		3F5D1E6368384D429BA29D5A /* IFCReaderGen.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = IFCReaderGen.cpp; path = code/IFCReaderGen.cpp; sourceTree = SOURCE_ROOT; };
+		409C98EE093C499B8A574CA9 /* PlyLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = PlyLoader.cpp; path = code/PlyLoader.cpp; sourceTree = SOURCE_ROOT; };
+		4108529663904025B21E526B /* ObjFileMtlImporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ObjFileMtlImporter.cpp; path = code/ObjFileMtlImporter.cpp; sourceTree = SOURCE_ROOT; };
+		41C2F6D564924BF4ACE75CAC /* postprocess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = postprocess.h; path = include/assimp/postprocess.h; sourceTree = SOURCE_ROOT; };
+		420D77ED33554D54AA4D50EF /* ColladaParser.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ColladaParser.cpp; path = code/ColladaParser.cpp; sourceTree = SOURCE_ROOT; };
+		42E110B9E6924AF9B55AE65A /* FBXMeshGeometry.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FBXMeshGeometry.cpp; path = code/FBXMeshGeometry.cpp; sourceTree = SOURCE_ROOT; };
+		42E68041B1C442E3B49FC304 /* B3DImporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = B3DImporter.h; path = code/B3DImporter.h; sourceTree = SOURCE_ROOT; };
+		435DC362E63D4CCBA68656D3 /* XFileExporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = XFileExporter.cpp; path = code/XFileExporter.cpp; sourceTree = SOURCE_ROOT; };
+		43899EB0B0704A9DB8F0C54F /* BlenderDNA.inl */ = {isa = PBXFileReference; explicitFileType = sourcecode; fileEncoding = 4; name = BlenderDNA.inl; path = code/BlenderDNA.inl; sourceTree = SOURCE_ROOT; };
+		43ABFF591F374920A5E18A24 /* HMPLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = HMPLoader.cpp; path = code/HMPLoader.cpp; sourceTree = SOURCE_ROOT; };
+		43C75175738C4119871E8BB0 /* Q3BSPZipArchive.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = Q3BSPZipArchive.cpp; path = code/Q3BSPZipArchive.cpp; sourceTree = SOURCE_ROOT; };
+		43FC808D2F4745ACB06A9D33 /* MD5Parser.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MD5Parser.h; path = code/MD5Parser.h; sourceTree = SOURCE_ROOT; };
+		445F70426FCC42F088405E86 /* COBLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = COBLoader.h; path = code/COBLoader.h; sourceTree = SOURCE_ROOT; };
+		4493838DDEE841BF96A0F008 /* matrix4x4.inl */ = {isa = PBXFileReference; explicitFileType = sourcecode; fileEncoding = 4; name = matrix4x4.inl; path = include/assimp/matrix4x4.inl; sourceTree = SOURCE_ROOT; };
+		4568875B66584E12AA1538C7 /* BlenderBMesh.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = BlenderBMesh.h; path = code/BlenderBMesh.h; sourceTree = SOURCE_ROOT; };
+		45BC2EB74251493CBBFAEB5D /* SkeletonMeshBuilder.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = SkeletonMeshBuilder.h; path = code/SkeletonMeshBuilder.h; sourceTree = SOURCE_ROOT; };
+		45E342A1499E4F03ADD49028 /* BVHLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = BVHLoader.h; path = code/BVHLoader.h; sourceTree = SOURCE_ROOT; };
+		45F6A2B351AB4B749E55B299 /* PlyParser.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = PlyParser.h; path = code/PlyParser.h; sourceTree = SOURCE_ROOT; };
+		466D6B9A7CCD402D9AA87071 /* DXFLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = DXFLoader.cpp; path = code/DXFLoader.cpp; sourceTree = SOURCE_ROOT; };
+		46E9F455A3284DB399986293 /* IFCProfile.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = IFCProfile.cpp; path = code/IFCProfile.cpp; sourceTree = SOURCE_ROOT; };
+		4770D6DCA1854B4F9B85546A /* DeboneProcess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = DeboneProcess.h; path = code/DeboneProcess.h; sourceTree = SOURCE_ROOT; };
+		47FF3063906E4786ABF0939B /* STEPFile.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = STEPFile.h; path = code/STEPFile.h; sourceTree = SOURCE_ROOT; };
+		4866DA5A7BFD49F79B61CBF8 /* TerragenLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = TerragenLoader.cpp; path = code/TerragenLoader.cpp; sourceTree = SOURCE_ROOT; };
+		4936396409984881858E7B15 /* irrTypes.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = irrTypes.h; path = contrib/irrXML/irrTypes.h; sourceTree = SOURCE_ROOT; };
+		49AFF879142C4BA4865843DC /* Bitmap.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = Bitmap.h; path = code/Bitmap.h; sourceTree = SOURCE_ROOT; };
+		49B655CCE1314D4E8A94B371 /* MD2Loader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = MD2Loader.cpp; path = code/MD2Loader.cpp; sourceTree = SOURCE_ROOT; };
+		49E993CD86A346869AF473BC /* sweep.cc */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = sweep.cc; path = contrib/poly2tri/poly2tri/sweep/sweep.cc; sourceTree = SOURCE_ROOT; };
+		49FE5C30FC854A3EBD0E9C19 /* irrArray.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = irrArray.h; path = contrib/irrXML/irrArray.h; sourceTree = SOURCE_ROOT; };
+		4A60A00727F04E049CF3AE33 /* Q3BSPFileParser.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = Q3BSPFileParser.cpp; path = code/Q3BSPFileParser.cpp; sourceTree = SOURCE_ROOT; };
+		4B571231CE2B464BBF1E853F /* FindDegenerates.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = FindDegenerates.h; path = code/FindDegenerates.h; sourceTree = SOURCE_ROOT; };
+		4BBDEB63CFEB4F2EAA95358D /* Subdivision.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = Subdivision.cpp; path = code/Subdivision.cpp; sourceTree = SOURCE_ROOT; };
+		4CBC1122A79D4F6C94E36CE3 /* StdOStreamLogStream.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = StdOStreamLogStream.h; path = code/StdOStreamLogStream.h; sourceTree = SOURCE_ROOT; };
+		4D2F1605B9484B08BB33402D /* STLLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = STLLoader.cpp; path = code/STLLoader.cpp; sourceTree = SOURCE_ROOT; };
+		4D82A29A8BBF44E69E026F84 /* importerdesc.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = importerdesc.h; path = include/assimp/importerdesc.h; sourceTree = SOURCE_ROOT; };
+		4DABF3CB245F4246B0184513 /* ACLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ACLoader.h; path = code/ACLoader.h; sourceTree = SOURCE_ROOT; };
+		4FE1E4726B144AD1B922A1A0 /* ScenePreprocessor.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ScenePreprocessor.h; path = code/ScenePreprocessor.h; sourceTree = SOURCE_ROOT; };
+		501B18C2B590455D8A3C3E78 /* XGLLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = XGLLoader.h; path = code/XGLLoader.h; sourceTree = SOURCE_ROOT; };
+		50935A81362041BEADF18609 /* utils.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = utils.h; path = contrib/poly2tri/poly2tri/common/utils.h; sourceTree = SOURCE_ROOT; };
+		52836A0629E24447B924750A /* SGSpatialSort.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = SGSpatialSort.cpp; path = code/SGSpatialSort.cpp; sourceTree = SOURCE_ROOT; };
+		531FBC4210644C61954EA4C4 /* MD2Loader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MD2Loader.h; path = code/MD2Loader.h; sourceTree = SOURCE_ROOT; };
+		53537D08E9B44A25B43B697B /* XFileImporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = XFileImporter.h; path = code/XFileImporter.h; sourceTree = SOURCE_ROOT; };
+		5631CE86F56F458EA0E2415F /* HMPLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = HMPLoader.h; path = code/HMPLoader.h; sourceTree = SOURCE_ROOT; };
+		563FBACCFD774BDEA4AEAC10 /* MD3Loader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = MD3Loader.cpp; path = code/MD3Loader.cpp; sourceTree = SOURCE_ROOT; };
+		56ADEC4899C047F2839AD791 /* OgreBinarySerializer.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = OgreBinarySerializer.cpp; path = code/OgreBinarySerializer.cpp; sourceTree = SOURCE_ROOT; };
+		56CE07D64D114C4BAB6D9F08 /* Logger.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = Logger.hpp; path = include/assimp/Logger.hpp; sourceTree = SOURCE_ROOT; };
+		56DA1CDC223747F4AFBAF953 /* types.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = types.h; path = include/assimp/types.h; sourceTree = SOURCE_ROOT; };
+		59A1859480754E90B958CA85 /* BlenderTessellator.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = BlenderTessellator.h; path = code/BlenderTessellator.h; sourceTree = SOURCE_ROOT; };
+		59E3D32E3FC7438DB148537F /* IFCUtil.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = IFCUtil.cpp; path = code/IFCUtil.cpp; sourceTree = SOURCE_ROOT; };
+		59F8A11A7AED45CC94CEDF28 /* clipper.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = clipper.cpp; path = contrib/clipper/clipper.cpp; sourceTree = SOURCE_ROOT; };
+		5A4E05386C094B809A315A07 /* LWOLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = LWOLoader.cpp; path = code/LWOLoader.cpp; sourceTree = SOURCE_ROOT; };
+		5C15EEB253204E8A8E0D0E38 /* Q3BSPFileParser.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = Q3BSPFileParser.h; path = code/Q3BSPFileParser.h; sourceTree = SOURCE_ROOT; };
+		5C1EA03E3AE24AA5A778B7F1 /* Profiler.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = Profiler.h; path = code/Profiler.h; sourceTree = SOURCE_ROOT; };
+		5D4E64EABD9548A59E9637AF /* irrString.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = irrString.h; path = contrib/irrXML/irrString.h; sourceTree = SOURCE_ROOT; };
+		5E10483FBE6D4F4594B460E0 /* sweep_context.cc */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = sweep_context.cc; path = contrib/poly2tri/poly2tri/sweep/sweep_context.cc; sourceTree = SOURCE_ROOT; };
+		5F373DF3B03B4B848B78EAD2 /* FBXParser.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FBXParser.cpp; path = code/FBXParser.cpp; sourceTree = SOURCE_ROOT; };
+		5F84BDD0D5D345A2BF1E08E1 /* metadata.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = metadata.h; path = include/assimp/metadata.h; sourceTree = SOURCE_ROOT; };
+		5FBE72DCC6AC485ABCF89B8C /* ImproveCacheLocality.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ImproveCacheLocality.h; path = code/ImproveCacheLocality.h; sourceTree = SOURCE_ROOT; };
+		603AFA882AFF49AEAC2C8FA2 /* BlenderBMesh.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = BlenderBMesh.cpp; path = code/BlenderBMesh.cpp; sourceTree = SOURCE_ROOT; };
+		6162B57DE81A4E538430056E /* IFCReaderGen.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = IFCReaderGen.h; path = code/IFCReaderGen.h; sourceTree = SOURCE_ROOT; };
+		621E96E95F60421EB6B4525C /* MDCLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MDCLoader.h; path = code/MDCLoader.h; sourceTree = SOURCE_ROOT; };
+		62E8551653634972ABBABCAD /* sweep.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = sweep.h; path = contrib/poly2tri/poly2tri/sweep/sweep.h; sourceTree = SOURCE_ROOT; };
+		6347FA5D391D4320B9457D3F /* MS3DLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MS3DLoader.h; path = code/MS3DLoader.h; sourceTree = SOURCE_ROOT; };
+		6389F68312384CFD847B1D13 /* AssbinExporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = AssbinExporter.cpp; path = code/AssbinExporter.cpp; sourceTree = SOURCE_ROOT; };
+		638B3F6AC17A435C9B86C86C /* ColladaExporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ColladaExporter.h; path = code/ColladaExporter.h; sourceTree = SOURCE_ROOT; };
+		6454A961FAF44B3E9086D2F8 /* Q3BSPZipArchive.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = Q3BSPZipArchive.h; path = code/Q3BSPZipArchive.h; sourceTree = SOURCE_ROOT; };
+		64C6BACDA5DD4139AA26EE81 /* irrXML.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = irrXML.cpp; path = contrib/irrXML/irrXML.cpp; sourceTree = SOURCE_ROOT; };
+		657B9A15EE7A4B7BA519A969 /* LogStream.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = LogStream.hpp; path = include/assimp/LogStream.hpp; sourceTree = SOURCE_ROOT; };
+		670FE6DD7EDF421488F2F97F /* IRRMeshLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = IRRMeshLoader.h; path = code/IRRMeshLoader.h; sourceTree = SOURCE_ROOT; };
+		680C392FFE0B4CC5ABC7CA64 /* LWOAnimation.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = LWOAnimation.cpp; path = code/LWOAnimation.cpp; sourceTree = SOURCE_ROOT; };
+		680FBD79376A41B690C405B8 /* LineSplitter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = LineSplitter.h; path = code/LineSplitter.h; sourceTree = SOURCE_ROOT; };
+		68703F99581F49CB9E2B9F37 /* LWSLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = LWSLoader.h; path = code/LWSLoader.h; sourceTree = SOURCE_ROOT; };
+		6981B16018CF46CAA54C0BAA /* ColladaLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ColladaLoader.h; path = code/ColladaLoader.h; sourceTree = SOURCE_ROOT; };
+		69AFF47737244CE3BD1653CC /* ProgressHandler.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = ProgressHandler.hpp; path = include/assimp/ProgressHandler.hpp; sourceTree = SOURCE_ROOT; };
+		6A86069DEEDC42B88634F78D /* RemoveComments.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = RemoveComments.cpp; path = code/RemoveComments.cpp; sourceTree = SOURCE_ROOT; };
+		6AC645CEB6F74AE5A62DF68B /* IFF.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = IFF.h; path = code/IFF.h; sourceTree = SOURCE_ROOT; };
+		6BAB32C8E06E43689FC5E7EA /* MD5Loader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MD5Loader.h; path = code/MD5Loader.h; sourceTree = SOURCE_ROOT; };
+		6CC21F1D0E4140FE923E4EE6 /* AssbinExporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = AssbinExporter.h; path = code/AssbinExporter.h; sourceTree = SOURCE_ROOT; };
+		6D72952403D04713A6451654 /* vector3.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = vector3.h; path = include/assimp/vector3.h; sourceTree = SOURCE_ROOT; };
+		6E20FCC571F144DDBD831CCB /* DeboneProcess.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = DeboneProcess.cpp; path = code/DeboneProcess.cpp; sourceTree = SOURCE_ROOT; };
+		6E82409E9D274D278971F3B0 /* Q3BSPFileData.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = Q3BSPFileData.h; path = code/Q3BSPFileData.h; sourceTree = SOURCE_ROOT; };
+		6F49958B5CCF423681133515 /* OgreParsingUtils.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = OgreParsingUtils.h; path = code/OgreParsingUtils.h; sourceTree = SOURCE_ROOT; };
+		6F65B6129F774AEDB8DC845A /* TargetAnimation.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = TargetAnimation.cpp; path = code/TargetAnimation.cpp; sourceTree = SOURCE_ROOT; };
+		6F88E78E61FC4A01BC30BE85 /* ConvertUTF.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ConvertUTF.h; path = contrib/ConvertUTF/ConvertUTF.h; sourceTree = SOURCE_ROOT; };
+		705D30EE141A48F292783F0E /* Assimp.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = Assimp.cpp; path = code/Assimp.cpp; sourceTree = SOURCE_ROOT; };
+		70D5FDFA995E45E6A3E8FD37 /* ImproveCacheLocality.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ImproveCacheLocality.cpp; path = code/ImproveCacheLocality.cpp; sourceTree = SOURCE_ROOT; };
+		71EAFDE1910B4A54AAAF2101 /* HMPFileData.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = HMPFileData.h; path = code/HMPFileData.h; sourceTree = SOURCE_ROOT; };
+		71F65BF6936E4E97A5933EF9 /* OgreImporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = OgreImporter.h; path = code/OgreImporter.h; sourceTree = SOURCE_ROOT; };
+		725DAD1CE04C4F64BDAB7037 /* ValidateDataStructure.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ValidateDataStructure.h; path = code/ValidateDataStructure.h; sourceTree = SOURCE_ROOT; };
+		72832410F47C44E3BAE709C2 /* BlenderDNA.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = BlenderDNA.h; path = code/BlenderDNA.h; sourceTree = SOURCE_ROOT; };
+		72F2DF0B93CF4D3ABAD7513D /* LWOLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = LWOLoader.h; path = code/LWOLoader.h; sourceTree = SOURCE_ROOT; };
+		72F637AC7D9E4FBFBB9201CE /* ioapi.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ioapi.h; path = contrib/unzip/ioapi.h; sourceTree = SOURCE_ROOT; };
+		731205CAB88247C095E33412 /* Exporter.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = Exporter.hpp; path = include/assimp/Exporter.hpp; sourceTree = SOURCE_ROOT; };
+		73A3D87FF2C04C3BA3684F54 /* SceneCombiner.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = SceneCombiner.cpp; path = code/SceneCombiner.cpp; sourceTree = SOURCE_ROOT; };
+		74679D2078FD46ED9AC73355 /* IFCOpenings.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = IFCOpenings.cpp; path = code/IFCOpenings.cpp; sourceTree = SOURCE_ROOT; };
+		74C02A113B804568A7E39CBC /* XFileParser.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = XFileParser.cpp; path = code/XFileParser.cpp; sourceTree = SOURCE_ROOT; };
+		7644CE6B26D740258577EE9D /* scoped_ptr.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = scoped_ptr.hpp; path = code/BoostWorkaround/boost/scoped_ptr.hpp; sourceTree = SOURCE_ROOT; };
+		76773A53296549FFA43956A1 /* Q3DLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = Q3DLoader.h; path = code/Q3DLoader.h; sourceTree = SOURCE_ROOT; };
+		76D801D898C4443D8240EDB7 /* BlenderSceneGen.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = BlenderSceneGen.h; path = code/BlenderSceneGen.h; sourceTree = SOURCE_ROOT; };
+		77908990BEF04D0881E8AE80 /* CSMLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = CSMLoader.cpp; path = code/CSMLoader.cpp; sourceTree = SOURCE_ROOT; };
+		79A49EFE23E34E1CBA2E4377 /* OgreStructs.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = OgreStructs.cpp; path = code/OgreStructs.cpp; sourceTree = SOURCE_ROOT; };
+		7BDF90B124F74A39A5EB3B02 /* DXFLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = DXFLoader.h; path = code/DXFLoader.h; sourceTree = SOURCE_ROOT; };
+		7C10178C0B7241DD874A0AF3 /* ColladaHelper.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ColladaHelper.h; path = code/ColladaHelper.h; sourceTree = SOURCE_ROOT; };
+		7C477FA4D89548F1BCEDC5A0 /* ASELoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ASELoader.cpp; path = code/ASELoader.cpp; sourceTree = SOURCE_ROOT; };
+		7C63156710964DEDAC0929BD /* HalfLifeFileData.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = HalfLifeFileData.h; path = code/HalfLifeFileData.h; sourceTree = SOURCE_ROOT; };
+		7CAF8A3096E04CB983B53CC1 /* BlenderIntermediate.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = BlenderIntermediate.h; path = code/BlenderIntermediate.h; sourceTree = SOURCE_ROOT; };
+		7DC4B0B5E57F4F4892CC823E /* MemoryIOWrapper.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MemoryIOWrapper.h; path = code/MemoryIOWrapper.h; sourceTree = SOURCE_ROOT; };
+		7E8BA0D338C9433587BC6C35 /* StreamWriter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = StreamWriter.h; path = code/StreamWriter.h; sourceTree = SOURCE_ROOT; };
+		7F29EF981AB26C4900E9D380 /* libz.1.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libz.1.dylib; path = /usr/lib/libz.1.dylib; sourceTree = "<absolute>"; };
+		7F392D921AB2C7BB00D952EB /* libc++.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = "libc++.dylib"; path = "/usr/lib/libc++.dylib"; sourceTree = "<absolute>"; };
+		7F7922801AB43AC3005A8E5D /* libassimp.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libassimp.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		7F7A93A51B65D0110094C4DA /* DDLNode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DDLNode.cpp; path = contrib/openddlparser/code/DDLNode.cpp; sourceTree = "<group>"; };
+		7F7A93A61B65D0110094C4DA /* OpenDDLParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = OpenDDLParser.cpp; path = contrib/openddlparser/code/OpenDDLParser.cpp; sourceTree = "<group>"; };
+		7F7A93A71B65D0110094C4DA /* Value.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Value.cpp; path = contrib/openddlparser/code/Value.cpp; sourceTree = "<group>"; };
+		7FBE9FE51B65AC1200D2115E /* OpenGEXExporter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = OpenGEXExporter.cpp; path = code/OpenGEXExporter.cpp; sourceTree = "<group>"; };
+		7FBE9FE61B65AC1200D2115E /* OpenGEXExporter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = OpenGEXExporter.h; path = code/OpenGEXExporter.h; sourceTree = "<group>"; };
+		7FBE9FE71B65AC1200D2115E /* OpenGEXImporter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = OpenGEXImporter.cpp; path = code/OpenGEXImporter.cpp; sourceTree = "<group>"; };
+		7FBE9FE81B65AC1200D2115E /* OpenGEXImporter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = OpenGEXImporter.h; path = code/OpenGEXImporter.h; sourceTree = "<group>"; };
+		7FBE9FE91B65AC1200D2115E /* OpenGEXStructs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = OpenGEXStructs.h; path = code/OpenGEXStructs.h; sourceTree = "<group>"; };
+		7FBEA0071B65AF9200D2115E /* DDLNode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DDLNode.h; path = contrib/openddlparser/include/openddlparser/DDLNode.h; sourceTree = "<group>"; };
+		7FBEA0081B65AF9200D2115E /* OpenDDLCommon.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = OpenDDLCommon.h; path = contrib/openddlparser/include/openddlparser/OpenDDLCommon.h; sourceTree = "<group>"; };
+		7FBEA00A1B65AF9200D2115E /* OpenDDLParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = OpenDDLParser.h; path = contrib/openddlparser/include/openddlparser/OpenDDLParser.h; sourceTree = "<group>"; };
+		7FBEA00B1B65AF9200D2115E /* OpenDDLParserUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = OpenDDLParserUtils.h; path = contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h; sourceTree = "<group>"; };
+		7FBEA00D1B65AF9200D2115E /* Value.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Value.h; path = contrib/openddlparser/include/openddlparser/Value.h; sourceTree = "<group>"; };
+		7FBEA0111B65B11800D2115E /* Version.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Version.cpp; path = code/Version.cpp; sourceTree = "<group>"; };
+		7FF72CB6E99E40E19AE0E64C /* MaterialSystem.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = MaterialSystem.cpp; path = code/MaterialSystem.cpp; sourceTree = SOURCE_ROOT; };
+		815702BED5644DD5B242F347 /* TerragenLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = TerragenLoader.h; path = code/TerragenLoader.h; sourceTree = SOURCE_ROOT; };
+		8299401C3E4A43A18E887DC1 /* SGSpatialSort.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = SGSpatialSort.h; path = code/SGSpatialSort.h; sourceTree = SOURCE_ROOT; };
+		8343910BBD464297932B3CE0 /* FixNormalsStep.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = FixNormalsStep.h; path = code/FixNormalsStep.h; sourceTree = SOURCE_ROOT; };
+		8476FEE874C1404B9B4B9617 /* SceneCombiner.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = SceneCombiner.h; path = code/SceneCombiner.h; sourceTree = SOURCE_ROOT; };
+		849EC6315E4A4E5FA06521EA /* cdt.cc */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = cdt.cc; path = contrib/poly2tri/poly2tri/sweep/cdt.cc; sourceTree = SOURCE_ROOT; };
+		862131D4574B4CABA5EC957B /* ObjFileImporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ObjFileImporter.cpp; path = code/ObjFileImporter.cpp; sourceTree = SOURCE_ROOT; };
+		86E296E459F94050ACBA3C63 /* IOSystem.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = IOSystem.hpp; path = include/assimp/IOSystem.hpp; sourceTree = SOURCE_ROOT; };
+		88ADA502481B403191BD35F0 /* STLExporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = STLExporter.h; path = code/STLExporter.h; sourceTree = SOURCE_ROOT; };
+		890E32C714444692AA016AE5 /* ProcessHelper.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ProcessHelper.cpp; path = code/ProcessHelper.cpp; sourceTree = SOURCE_ROOT; };
+		89473420F7E448A7BE71FCBA /* FBXUtil.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = FBXUtil.h; path = code/FBXUtil.h; sourceTree = SOURCE_ROOT; };
+		89D2D359BD854D8AA60CB720 /* STLExporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = STLExporter.cpp; path = code/STLExporter.cpp; sourceTree = SOURCE_ROOT; };
+		8C9AEFFFF3B948148D32D76F /* shared_array.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = shared_array.hpp; path = code/BoostWorkaround/boost/shared_array.hpp; sourceTree = SOURCE_ROOT; };
+		8D53CC35AAED4CE8B9710E04 /* vector3.inl */ = {isa = PBXFileReference; explicitFileType = sourcecode; fileEncoding = 4; name = vector3.inl; path = include/assimp/vector3.inl; sourceTree = SOURCE_ROOT; };
+		8D977E197CA4477AB9F3278C /* NullLogger.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = NullLogger.hpp; path = include/assimp/NullLogger.hpp; sourceTree = SOURCE_ROOT; };
+		8E2108F568374F65ACE217D1 /* light.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = light.h; path = include/assimp/light.h; sourceTree = SOURCE_ROOT; };
+		8E395349546A4FDF843E6963 /* XGLLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = XGLLoader.cpp; path = code/XGLLoader.cpp; sourceTree = SOURCE_ROOT; };
+		8EEC6646FC044D1E9658A590 /* SpatialSort.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = SpatialSort.cpp; path = code/SpatialSort.cpp; sourceTree = SOURCE_ROOT; };
+		8F4261792A60481DA04E6E1A /* XFileHelper.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = XFileHelper.h; path = code/XFileHelper.h; sourceTree = SOURCE_ROOT; };
+		8FE8B4781BB3406EB3452154 /* ObjTools.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ObjTools.h; path = code/ObjTools.h; sourceTree = SOURCE_ROOT; };
+		904A696E49D540C2A880792B /* cdt.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = cdt.h; path = contrib/poly2tri/poly2tri/sweep/cdt.h; sourceTree = SOURCE_ROOT; };
+		906F71D342544BF381E1318E /* BlenderLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = BlenderLoader.cpp; path = code/BlenderLoader.cpp; sourceTree = SOURCE_ROOT; };
+		90949C7A51E84D3595D71A6B /* config.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = config.h; path = include/assimp/config.h; sourceTree = SOURCE_ROOT; };
+		90DD6CA40A5E41458E11FF3E /* CalcTangentsProcess.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = CalcTangentsProcess.cpp; path = code/CalcTangentsProcess.cpp; sourceTree = SOURCE_ROOT; };
+		916456789C75419DB1436FAD /* OgreBinarySerializer.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = OgreBinarySerializer.h; path = code/OgreBinarySerializer.h; sourceTree = SOURCE_ROOT; };
+		91D49B3C51684882A01EA492 /* PlyLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = PlyLoader.h; path = code/PlyLoader.h; sourceTree = SOURCE_ROOT; };
+		91EF6411C40946758A06144F /* ObjExporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ObjExporter.h; path = code/ObjExporter.h; sourceTree = SOURCE_ROOT; };
+		91FF8B1DCC0644008AE34A04 /* FindInvalidDataProcess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = FindInvalidDataProcess.h; path = code/FindInvalidDataProcess.h; sourceTree = SOURCE_ROOT; };
+		923283A9791E4B4E86D623FC /* OgreImporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = OgreImporter.cpp; path = code/OgreImporter.cpp; sourceTree = SOURCE_ROOT; };
+		926E8B7924144B349A88023D /* OptimizeGraph.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = OptimizeGraph.h; path = code/OptimizeGraph.h; sourceTree = SOURCE_ROOT; };
+		9293C5A353F9497A850E05D5 /* unzip.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = unzip.h; path = contrib/unzip/unzip.h; sourceTree = SOURCE_ROOT; };
+		929F59CCA32549EC884A5033 /* ASEParser.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ASEParser.cpp; path = code/ASEParser.cpp; sourceTree = SOURCE_ROOT; };
+		92D8734FFF9742B39A371B70 /* ConvertToLHProcess.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ConvertToLHProcess.cpp; path = code/ConvertToLHProcess.cpp; sourceTree = SOURCE_ROOT; };
+		9472EFB6831740DD91471337 /* Importer.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = Importer.cpp; path = code/Importer.cpp; sourceTree = SOURCE_ROOT; };
+		95641498F25A4F6FABBC03A4 /* MDCFileData.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MDCFileData.h; path = code/MDCFileData.h; sourceTree = SOURCE_ROOT; };
+		957FBC18FED2484F83308E36 /* SpatialSort.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = SpatialSort.h; path = code/SpatialSort.h; sourceTree = SOURCE_ROOT; };
+		967D69AC1A344D4E988F0B2C /* common_factor_rt.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = common_factor_rt.hpp; path = code/BoostWorkaround/boost/math/common_factor_rt.hpp; sourceTree = SOURCE_ROOT; };
+		96A02CBA1AE642BD9519719D /* make_shared.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = make_shared.hpp; path = code/BoostWorkaround/boost/make_shared.hpp; sourceTree = SOURCE_ROOT; };
+		973D4231A4AA4925B019FEEE /* unzip.c */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.c; fileEncoding = 4; name = unzip.c; path = contrib/unzip/unzip.c; sourceTree = SOURCE_ROOT; };
+		9761D873B9604504B9AD7CD5 /* defs.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = defs.h; path = include/assimp/defs.h; sourceTree = SOURCE_ROOT; };
+		97914BDA4AA34081855BF16C /* ScenePrivate.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ScenePrivate.h; path = code/ScenePrivate.h; sourceTree = SOURCE_ROOT; };
+		97DFA90F9D0C4B999C150B10 /* IRRLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = IRRLoader.cpp; path = code/IRRLoader.cpp; sourceTree = SOURCE_ROOT; };
+		97F52051AF4F478FA77AABBC /* quaternion.inl */ = {isa = PBXFileReference; explicitFileType = sourcecode; fileEncoding = 4; name = quaternion.inl; path = include/assimp/quaternion.inl; sourceTree = SOURCE_ROOT; };
+		982AE676D2364350B1FBD095 /* GenFaceNormalsProcess.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = GenFaceNormalsProcess.cpp; path = code/GenFaceNormalsProcess.cpp; sourceTree = SOURCE_ROOT; };
+		9855496CEA774F4FA7FBB862 /* FBXDeformer.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FBXDeformer.cpp; path = code/FBXDeformer.cpp; sourceTree = SOURCE_ROOT; };
+		99A4349D505F4CC593F48CF6 /* SplitByBoneCountProcess.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = SplitByBoneCountProcess.cpp; path = code/SplitByBoneCountProcess.cpp; sourceTree = SOURCE_ROOT; };
+		9A0960F123634603B15EEA38 /* ConvertUTF.c */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.c; fileEncoding = 4; name = ConvertUTF.c; path = contrib/ConvertUTF/ConvertUTF.c; sourceTree = SOURCE_ROOT; };
+		9A61AF384D4D45778698DD7D /* ASELoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ASELoader.h; path = code/ASELoader.h; sourceTree = SOURCE_ROOT; };
+		9B2827B3E64147E08A5AD334 /* SkeletonMeshBuilder.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = SkeletonMeshBuilder.cpp; path = code/SkeletonMeshBuilder.cpp; sourceTree = SOURCE_ROOT; };
+		9B4221AA0AD2418FAA45EB64 /* FindInvalidDataProcess.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FindInvalidDataProcess.cpp; path = code/FindInvalidDataProcess.cpp; sourceTree = SOURCE_ROOT; };
+		9C5E3F9248B64C7EBF20EC27 /* Hash.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = Hash.h; path = code/Hash.h; sourceTree = SOURCE_ROOT; };
+		9D203F78B24C4D7E8E2084A3 /* FBXProperties.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FBXProperties.cpp; path = code/FBXProperties.cpp; sourceTree = SOURCE_ROOT; };
+		9E0572B45F1F4605BD5C919D /* COBScene.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = COBScene.h; path = code/COBScene.h; sourceTree = SOURCE_ROOT; };
+		A06CBE89CFAB48E786F7A5C0 /* 3DSLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = 3DSLoader.h; path = code/3DSLoader.h; sourceTree = SOURCE_ROOT; };
+		A0AED12A1A6D4635A8CFB65A /* GenVertexNormalsProcess.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = GenVertexNormalsProcess.cpp; path = code/GenVertexNormalsProcess.cpp; sourceTree = SOURCE_ROOT; };
+		A14347E954E8413CAF1455EA /* LWOAnimation.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = LWOAnimation.h; path = code/LWOAnimation.h; sourceTree = SOURCE_ROOT; };
+		A1A9535EDF9A4FF2B8DABD7D /* AssimpCExport.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = AssimpCExport.cpp; path = code/AssimpCExport.cpp; sourceTree = SOURCE_ROOT; };
+		A257229A058041389981CFC1 /* XFileExporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = XFileExporter.h; path = code/XFileExporter.h; sourceTree = SOURCE_ROOT; };
+		A277DBC1EFB944F995659A20 /* MD5Loader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = MD5Loader.cpp; path = code/MD5Loader.cpp; sourceTree = SOURCE_ROOT; };
+		A3D3024C3A59423487A125C8 /* STEPFileReader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = STEPFileReader.h; path = code/STEPFileReader.h; sourceTree = SOURCE_ROOT; };
+		A43641DC9C1B4B578BC40476 /* SplitLargeMeshes.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = SplitLargeMeshes.cpp; path = code/SplitLargeMeshes.cpp; sourceTree = SOURCE_ROOT; };
+		A436C47FBF904FECB4A58462 /* ProcessHelper.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ProcessHelper.h; path = code/ProcessHelper.h; sourceTree = SOURCE_ROOT; };
+		A4CBF9157F01460ABEDEBF28 /* crypt.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = crypt.h; path = contrib/unzip/crypt.h; sourceTree = SOURCE_ROOT; };
+		A58410FEAA884A2D8D73ACCE /* BaseImporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = BaseImporter.cpp; path = code/BaseImporter.cpp; sourceTree = SOURCE_ROOT; };
+		A72115ED828F4069A427B460 /* Subdivision.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = Subdivision.h; path = code/Subdivision.h; sourceTree = SOURCE_ROOT; };
+		A7733823362B4A389102D177 /* TargetAnimation.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = TargetAnimation.h; path = code/TargetAnimation.h; sourceTree = SOURCE_ROOT; };
+		A7A56A688A3845768410F500 /* FBXConverter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FBXConverter.cpp; path = code/FBXConverter.cpp; sourceTree = SOURCE_ROOT; };
+		A7A86F81858F4D928A568E17 /* FBXConverter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = FBXConverter.h; path = code/FBXConverter.h; sourceTree = SOURCE_ROOT; };
+		A7A990C6FF244DC397B7BA7C /* MS3DLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = MS3DLoader.cpp; path = code/MS3DLoader.cpp; sourceTree = SOURCE_ROOT; };
+		A7CEBC6894424B888326CAB2 /* tuple.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = tuple.hpp; path = code/BoostWorkaround/boost/tuple/tuple.hpp; sourceTree = SOURCE_ROOT; };
+		A88D56FBEA084A3EA9A0ECB3 /* Q3BSPFileImporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = Q3BSPFileImporter.cpp; path = code/Q3BSPFileImporter.cpp; sourceTree = SOURCE_ROOT; };
+		A9E9EB834E09420197C3FB8C /* DefaultLogger.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = DefaultLogger.cpp; path = code/DefaultLogger.cpp; sourceTree = SOURCE_ROOT; };
+		AA4946AEDB9F4F22873C4C4F /* FBXImporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = FBXImporter.h; path = code/FBXImporter.h; sourceTree = SOURCE_ROOT; };
+		AA92FFC8B06D4569AD9C4CB1 /* MDLLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = MDLLoader.cpp; path = code/MDLLoader.cpp; sourceTree = SOURCE_ROOT; };
+		AAB9AE5328F843F5A8A3E85C /* OptimizeGraph.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = OptimizeGraph.cpp; path = code/OptimizeGraph.cpp; sourceTree = SOURCE_ROOT; };
+		AAD3EA9B0BB84A788FCCA83E /* foreach.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = foreach.hpp; path = code/BoostWorkaround/boost/foreach.hpp; sourceTree = SOURCE_ROOT; };
+		ABDA70358E34432A8A4637F4 /* RemoveVCProcess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = RemoveVCProcess.h; path = code/RemoveVCProcess.h; sourceTree = SOURCE_ROOT; };
+		AC699876B6364EC1878CBA44 /* OgreXmlSerializer.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = OgreXmlSerializer.h; path = code/OgreXmlSerializer.h; sourceTree = SOURCE_ROOT; };
+		ACF73EEAB2424213BF7158D5 /* ObjFileParser.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ObjFileParser.cpp; path = code/ObjFileParser.cpp; sourceTree = SOURCE_ROOT; };
+		AD969BA482564C7FAA372F7C /* RemoveRedundantMaterials.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = RemoveRedundantMaterials.h; path = code/RemoveRedundantMaterials.h; sourceTree = SOURCE_ROOT; };
+		ADACEBC4973F4FC0A6FEC68A /* RemoveRedundantMaterials.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = RemoveRedundantMaterials.cpp; path = code/RemoveRedundantMaterials.cpp; sourceTree = SOURCE_ROOT; };
+		AE00939F150F413780C8AAD7 /* shapes.cc */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = shapes.cc; path = contrib/poly2tri/poly2tri/common/shapes.cc; sourceTree = SOURCE_ROOT; };
+		AE1C2E2C9C424B3684AD9D4A /* texture.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = texture.h; path = include/assimp/texture.h; sourceTree = SOURCE_ROOT; };
+		AF75E6049338489BB256D295 /* ioapi.c */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.c; fileEncoding = 4; name = ioapi.c; path = contrib/unzip/ioapi.c; sourceTree = SOURCE_ROOT; };
+		AFA8B6DE5B3A4E52A85041C9 /* LWOFileData.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = LWOFileData.h; path = code/LWOFileData.h; sourceTree = SOURCE_ROOT; };
+		AFF41974881F466A9561BE4B /* LWSLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = LWSLoader.cpp; path = code/LWSLoader.cpp; sourceTree = SOURCE_ROOT; };
+		B04FE3598E344EC09B59CA2F /* IRRShared.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = IRRShared.h; path = code/IRRShared.h; sourceTree = SOURCE_ROOT; };
+		B05DC38593F04180B322360B /* camera.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = camera.h; path = include/assimp/camera.h; sourceTree = SOURCE_ROOT; };
+		B211101B342C414A9E43B7BC /* SplitByBoneCountProcess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = SplitByBoneCountProcess.h; path = code/SplitByBoneCountProcess.h; sourceTree = SOURCE_ROOT; };
+		B36DA471B9E142FC9425EC45 /* JoinVerticesProcess.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = JoinVerticesProcess.cpp; path = code/JoinVerticesProcess.cpp; sourceTree = SOURCE_ROOT; };
+		B3E8A1BEF8E74F04AE06871B /* AssxmlExporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = AssxmlExporter.cpp; path = code/AssxmlExporter.cpp; sourceTree = SOURCE_ROOT; };
+		B4086213AE40445F817FA840 /* RemoveComments.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = RemoveComments.h; path = code/RemoveComments.h; sourceTree = SOURCE_ROOT; };
+		B40FE1BF9D8E411493BBDE0C /* ComputeUVMappingProcess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ComputeUVMappingProcess.h; path = code/ComputeUVMappingProcess.h; sourceTree = SOURCE_ROOT; };
+		B441D87EE6ED4EBFB0586B66 /* anim.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = anim.h; path = include/assimp/anim.h; sourceTree = SOURCE_ROOT; };
+		B4C688FA08F44716855CDD3C /* FBXImporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FBXImporter.cpp; path = code/FBXImporter.cpp; sourceTree = SOURCE_ROOT; };
+		B4F1B5789CA540C78FB9219D /* NDOLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = NDOLoader.cpp; path = code/NDOLoader.cpp; sourceTree = SOURCE_ROOT; };
+		B522B83A39CA461CBCABE25A /* BlenderScene.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = BlenderScene.h; path = code/BlenderScene.h; sourceTree = SOURCE_ROOT; };
+		B54FBAAF061B40DBA3F48F83 /* IOStream.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = IOStream.hpp; path = include/assimp/IOStream.hpp; sourceTree = SOURCE_ROOT; };
+		B6074B1E864740F787A97EA3 /* vector2.inl */ = {isa = PBXFileReference; explicitFileType = sourcecode; fileEncoding = 4; name = vector2.inl; path = include/assimp/vector2.inl; sourceTree = SOURCE_ROOT; };
+		B65258E349704523BC43904D /* BlenderDNA.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = BlenderDNA.cpp; path = code/BlenderDNA.cpp; sourceTree = SOURCE_ROOT; };
+		B6982D8069A145E5B9F97684 /* DXFHelper.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = DXFHelper.h; path = code/DXFHelper.h; sourceTree = SOURCE_ROOT; };
+		B7192C50B16142398B7CD221 /* DefaultProgressHandler.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = DefaultProgressHandler.h; path = code/DefaultProgressHandler.h; sourceTree = SOURCE_ROOT; };
+		B72D0BA3EF66439F8D582ED3 /* advancing_front.cc */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = advancing_front.cc; path = contrib/poly2tri/poly2tri/sweep/advancing_front.cc; sourceTree = SOURCE_ROOT; };
+		B9DFF24FD63A4D9FAE213EED /* Importer.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = Importer.hpp; path = include/assimp/Importer.hpp; sourceTree = SOURCE_ROOT; };
+		BA832069DF214327AE067503 /* matrix4x4.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = matrix4x4.h; path = include/assimp/matrix4x4.h; sourceTree = SOURCE_ROOT; };
+		BABB7734139C452A9DDEE797 /* FindDegenerates.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FindDegenerates.cpp; path = code/FindDegenerates.cpp; sourceTree = SOURCE_ROOT; };
+		BB38E7E7661842448F008372 /* FBXDocumentUtil.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FBXDocumentUtil.cpp; path = code/FBXDocumentUtil.cpp; sourceTree = SOURCE_ROOT; };
+		BBEE1CF81183473C8492FC03 /* CalcTangentsProcess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = CalcTangentsProcess.h; path = code/CalcTangentsProcess.h; sourceTree = SOURCE_ROOT; };
+		BD9A81E0E27E44718609615B /* SortByPTypeProcess.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = SortByPTypeProcess.cpp; path = code/SortByPTypeProcess.cpp; sourceTree = SOURCE_ROOT; };
+		BDD30C77BB68497EA3B7F2F7 /* StringComparison.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = StringComparison.h; path = code/StringComparison.h; sourceTree = SOURCE_ROOT; };
+		BF94F50C216B45388CDEC1EF /* OFFLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = OFFLoader.h; path = code/OFFLoader.h; sourceTree = SOURCE_ROOT; };
+		C17C5037C995420C8D259C0C /* FBXImportSettings.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = FBXImportSettings.h; path = code/FBXImportSettings.h; sourceTree = SOURCE_ROOT; };
+		C18C5023460E4D17B8C922D7 /* StandardShapes.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = StandardShapes.cpp; path = code/StandardShapes.cpp; sourceTree = SOURCE_ROOT; };
+		C2C9EAC9B5B74AC397B070E8 /* scoped_array.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = scoped_array.hpp; path = code/BoostWorkaround/boost/scoped_array.hpp; sourceTree = SOURCE_ROOT; };
+		C490BBF1881240EEA4A96315 /* clipper.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = clipper.hpp; path = contrib/clipper/clipper.hpp; sourceTree = SOURCE_ROOT; };
+		C5178B3983F147F3B9BD8217 /* Q3DLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = Q3DLoader.cpp; path = code/Q3DLoader.cpp; sourceTree = SOURCE_ROOT; };
+		C54518F708BA4A328D5D7325 /* FixNormalsStep.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FixNormalsStep.cpp; path = code/FixNormalsStep.cpp; sourceTree = SOURCE_ROOT; };
+		C582480917FF4EB09C164D70 /* SMDLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = SMDLoader.h; path = code/SMDLoader.h; sourceTree = SOURCE_ROOT; };
+		C5C3ED2BE50D4684994BD533 /* TextureTransform.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = TextureTransform.h; path = code/TextureTransform.h; sourceTree = SOURCE_ROOT; };
+		C6D3C3E2BA2F49F2B17E7580 /* STLLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = STLLoader.h; path = code/STLLoader.h; sourceTree = SOURCE_ROOT; };
+		C7B37CA474DF4CE7A5B0658E /* ai_assert.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ai_assert.h; path = include/assimp/ai_assert.h; sourceTree = SOURCE_ROOT; };
+		C80B9A3AF4204AE08AA50BAE /* BVHLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = BVHLoader.cpp; path = code/BVHLoader.cpp; sourceTree = SOURCE_ROOT; };
+		C84DA0E6CE13493D833BA1C1 /* COBLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = COBLoader.cpp; path = code/COBLoader.cpp; sourceTree = SOURCE_ROOT; };
+		C9A101D1311C4E77AAEDD94C /* FindInstancesProcess.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FindInstancesProcess.cpp; path = code/FindInstancesProcess.cpp; sourceTree = SOURCE_ROOT; };
+		CB042D863BD447FFB117AE34 /* 3DSHelper.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = 3DSHelper.h; path = code/3DSHelper.h; sourceTree = SOURCE_ROOT; };
+		CC54A231FF6B4B0CABCFD167 /* IRRShared.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = IRRShared.cpp; path = code/IRRShared.cpp; sourceTree = SOURCE_ROOT; };
+		CC5D5CA1789448E9869B9669 /* PlyExporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = PlyExporter.h; path = code/PlyExporter.h; sourceTree = SOURCE_ROOT; };
+		CDE3ECA98173418A9F997992 /* STEPFileReader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = STEPFileReader.cpp; path = code/STEPFileReader.cpp; sourceTree = SOURCE_ROOT; };
+		CEC69808E1844C23B95D3475 /* MDLMaterialLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = MDLMaterialLoader.cpp; path = code/MDLMaterialLoader.cpp; sourceTree = SOURCE_ROOT; };
+		CF07D05DC86F4C98BC42FDCF /* FBXTokenizer.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FBXTokenizer.cpp; path = code/FBXTokenizer.cpp; sourceTree = SOURCE_ROOT; };
+		D029CE902F8045B0B3AFFDDB /* ImporterRegistry.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ImporterRegistry.cpp; path = code/ImporterRegistry.cpp; sourceTree = SOURCE_ROOT; };
+		D0E9BB0220704C5D93CE7CE9 /* IFCLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = IFCLoader.cpp; path = code/IFCLoader.cpp; sourceTree = SOURCE_ROOT; };
+		D1073FF20359469D921C9316 /* irrXMLWrapper.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = irrXMLWrapper.h; path = code/irrXMLWrapper.h; sourceTree = SOURCE_ROOT; };
+		D2869C6AD4814588A45E8F81 /* NFFLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = NFFLoader.h; path = code/NFFLoader.h; sourceTree = SOURCE_ROOT; };
+		D2EEB62ECBF749AA89146C66 /* SplitLargeMeshes.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = SplitLargeMeshes.h; path = code/SplitLargeMeshes.h; sourceTree = SOURCE_ROOT; };
+		D40F70AC841D4B788B5C696B /* CXMLReaderImpl.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = CXMLReaderImpl.h; path = contrib/irrXML/CXMLReaderImpl.h; sourceTree = SOURCE_ROOT; };
+		D56A4C70F65D4E07BD792D2C /* STEPFileEncoding.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = STEPFileEncoding.h; path = code/STEPFileEncoding.h; sourceTree = SOURCE_ROOT; };
+		D5F4108F03D7457EB641836B /* MDLFileData.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MDLFileData.h; path = code/MDLFileData.h; sourceTree = SOURCE_ROOT; };
+		D629F6BF53864979B7619067 /* LWOBLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = LWOBLoader.cpp; path = code/LWOBLoader.cpp; sourceTree = SOURCE_ROOT; };
+		D82B5BA87B184532BE74D24F /* LogAux.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = LogAux.h; path = code/LogAux.h; sourceTree = SOURCE_ROOT; };
+		D958B0B445E64F4BA9145D82 /* DefaultLogger.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = DefaultLogger.hpp; path = include/assimp/DefaultLogger.hpp; sourceTree = SOURCE_ROOT; };
+		D9AB66BD27E246A18091626F /* DefaultIOSystem.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = DefaultIOSystem.h; path = code/DefaultIOSystem.h; sourceTree = SOURCE_ROOT; };
+		D9FEEF58B24548F782A5D53C /* AssbinLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = AssbinLoader.cpp; path = code/AssbinLoader.cpp; sourceTree = SOURCE_ROOT; };
+		DAE82F651F9E4D91A6A6C753 /* advancing_front.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = advancing_front.h; path = contrib/poly2tri/poly2tri/sweep/advancing_front.h; sourceTree = SOURCE_ROOT; };
+		DC0210D3F25F470C86F914B3 /* ColladaParser.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = ColladaParser.h; path = code/ColladaParser.h; sourceTree = SOURCE_ROOT; };
+		DC67FF8B4313494F8C03D840 /* XMLTools.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = XMLTools.h; path = code/XMLTools.h; sourceTree = SOURCE_ROOT; };
+		DD3D18BC2E58447D9879CB00 /* OptimizeMeshes.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = OptimizeMeshes.h; path = code/OptimizeMeshes.h; sourceTree = SOURCE_ROOT; };
+		DD4E4641B0FE4369BF3775C3 /* MDCNormalTable.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MDCNormalTable.h; path = code/MDCNormalTable.h; sourceTree = SOURCE_ROOT; };
+		DD7FFD53046F4AEB898C0832 /* IRRMeshLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = IRRMeshLoader.cpp; path = code/IRRMeshLoader.cpp; sourceTree = SOURCE_ROOT; };
+		DDDE82BDF4F94E0EA35649A4 /* LimitBoneWeightsProcess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = LimitBoneWeightsProcess.h; path = code/LimitBoneWeightsProcess.h; sourceTree = SOURCE_ROOT; };
+		DE0D259917354C80BE1CC791 /* BlenderScene.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = BlenderScene.cpp; path = code/BlenderScene.cpp; sourceTree = SOURCE_ROOT; };
+		DE811A81663A492A84E13937 /* ObjExporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ObjExporter.cpp; path = code/ObjExporter.cpp; sourceTree = SOURCE_ROOT; };
+		DF76D04D95E649BCBC15E64F /* TextureTransform.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = TextureTransform.cpp; path = code/TextureTransform.cpp; sourceTree = SOURCE_ROOT; };
+		DFF8AF202CAA40E69D1A2BD0 /* static_assert.hpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; name = static_assert.hpp; path = code/BoostWorkaround/boost/static_assert.hpp; sourceTree = SOURCE_ROOT; };
+		E01801CB159D47928B3D96B5 /* TinyFormatter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = TinyFormatter.h; path = code/TinyFormatter.h; sourceTree = SOURCE_ROOT; };
+		E065DB38B0284196A9283CA3 /* LimitBoneWeightsProcess.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = LimitBoneWeightsProcess.cpp; path = code/LimitBoneWeightsProcess.cpp; sourceTree = SOURCE_ROOT; };
+		E11A39E91576445599DF2AC4 /* STEPFileEncoding.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = STEPFileEncoding.cpp; path = code/STEPFileEncoding.cpp; sourceTree = SOURCE_ROOT; };
+		E1313C36045444619026E9FB /* cfileio.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = cfileio.h; path = include/assimp/cfileio.h; sourceTree = SOURCE_ROOT; };
+		E24E950227C848D3A759F5C2 /* MDLLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MDLLoader.h; path = code/MDLLoader.h; sourceTree = SOURCE_ROOT; };
+		E51043448F1744FFA78526D5 /* PlyExporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = PlyExporter.cpp; path = code/PlyExporter.cpp; sourceTree = SOURCE_ROOT; };
+		E6332CD992D447CA910DA456 /* FBXUtil.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FBXUtil.cpp; path = code/FBXUtil.cpp; sourceTree = SOURCE_ROOT; };
+		E663847651834244834CB9F5 /* PostStepRegistry.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = PostStepRegistry.cpp; path = code/PostStepRegistry.cpp; sourceTree = SOURCE_ROOT; };
+		E7E85BF696E74CFAAEBF895C /* FBXTokenizer.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = FBXTokenizer.h; path = code/FBXTokenizer.h; sourceTree = SOURCE_ROOT; };
+		E81BAB0ED0854DDFA62CB956 /* pushpack1.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = pushpack1.h; path = include/assimp/Compiler/pushpack1.h; sourceTree = SOURCE_ROOT; };
+		E9ED3048A21E483F9C2721F4 /* mesh.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = mesh.h; path = include/assimp/mesh.h; sourceTree = SOURCE_ROOT; };
+		EAD338BE19AE4C2E897B38B6 /* RawLoader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = RawLoader.h; path = code/RawLoader.h; sourceTree = SOURCE_ROOT; };
+		EAD34F1AA6664B6B935C9421 /* FBXAnimation.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FBXAnimation.cpp; path = code/FBXAnimation.cpp; sourceTree = SOURCE_ROOT; };
+		ECCBBF2D75A44335AB93C84A /* 3DSExporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = 3DSExporter.cpp; path = code/3DSExporter.cpp; sourceTree = SOURCE_ROOT; };
+		ED20428B31DF46C6A9D65322 /* StreamReader.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = StreamReader.h; path = code/StreamReader.h; sourceTree = SOURCE_ROOT; };
+		EE545B58FA1246C792C6AD01 /* shapes.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = shapes.h; path = contrib/poly2tri/poly2tri/common/shapes.h; sourceTree = SOURCE_ROOT; };
+		EE6163EB035149A6B8139DB8 /* FBXMaterial.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FBXMaterial.cpp; path = code/FBXMaterial.cpp; sourceTree = SOURCE_ROOT; };
+		EF9F805A4BA4428CA98C9DE5 /* OgreXmlSerializer.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = OgreXmlSerializer.cpp; path = code/OgreXmlSerializer.cpp; sourceTree = SOURCE_ROOT; };
+		EFD557FE2C3A46D78F070655 /* OFFLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = OFFLoader.cpp; path = code/OFFLoader.cpp; sourceTree = SOURCE_ROOT; };
+		F1076BAC69DB4935A93045A8 /* ACLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = ACLoader.cpp; path = code/ACLoader.cpp; sourceTree = SOURCE_ROOT; };
+		F1A7BD0B5CAE48699FCAEBD1 /* MDLDefaultColorMap.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MDLDefaultColorMap.h; path = code/MDLDefaultColorMap.h; sourceTree = SOURCE_ROOT; };
+		F22D5BA425444A028DA42BEA /* FBXDocument.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = FBXDocument.cpp; path = code/FBXDocument.cpp; sourceTree = SOURCE_ROOT; };
+		F44E3625C31843B0AFA1A744 /* AssxmlExporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = AssxmlExporter.h; path = code/AssxmlExporter.h; sourceTree = SOURCE_ROOT; };
+		F468200042534D7CA2C9D891 /* BaseProcess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = BaseProcess.h; path = code/BaseProcess.h; sourceTree = SOURCE_ROOT; };
+		F4AE5F74C20B400EA688B5ED /* VertexTriangleAdjacency.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = VertexTriangleAdjacency.h; path = code/VertexTriangleAdjacency.h; sourceTree = SOURCE_ROOT; };
+		F4BA09C943DD49E184316D97 /* Win32DebugLogStream.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = Win32DebugLogStream.h; path = code/Win32DebugLogStream.h; sourceTree = SOURCE_ROOT; };
+		F5720C42345840CB9FEA5A40 /* BlenderModifier.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = BlenderModifier.h; path = code/BlenderModifier.h; sourceTree = SOURCE_ROOT; };
+		F75457C6D026451B9267B65E /* OgreMaterial.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = OgreMaterial.cpp; path = code/OgreMaterial.cpp; sourceTree = SOURCE_ROOT; };
+		F81AE18E4AA94F9597FCB040 /* Importer.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = Importer.h; path = code/Importer.h; sourceTree = SOURCE_ROOT; };
+		F898EEA0D9E64425A790587D /* Q3BSPFileImporter.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = Q3BSPFileImporter.h; path = code/Q3BSPFileImporter.h; sourceTree = SOURCE_ROOT; };
+		F8AC3A243B9C47D6B31348BA /* FBXParser.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = FBXParser.h; path = code/FBXParser.h; sourceTree = SOURCE_ROOT; };
+		F8B1133805564E18B32FFA83 /* OgreStructs.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = OgreStructs.h; path = code/OgreStructs.h; sourceTree = SOURCE_ROOT; };
+		F9FEF4D69EFC4605A4F752E5 /* DefaultIOStream.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = DefaultIOStream.cpp; path = code/DefaultIOStream.cpp; sourceTree = SOURCE_ROOT; };
+		FAB6BC13FCFE40F5801D0972 /* BaseProcess.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = BaseProcess.cpp; path = code/BaseProcess.cpp; sourceTree = SOURCE_ROOT; };
+		FAC67CC462484F92A2CBD7D3 /* poppack1.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = poppack1.h; path = include/assimp/Compiler/poppack1.h; sourceTree = SOURCE_ROOT; };
+		FB1E84BE85A34F98A44BBB2B /* vector2.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = vector2.h; path = include/assimp/vector2.h; sourceTree = SOURCE_ROOT; };
+		FB2510D46F504365A03EE8A8 /* TriangulateProcess.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = TriangulateProcess.h; path = code/TriangulateProcess.h; sourceTree = SOURCE_ROOT; };
+		FB4ABA17AF264257BDA4D921 /* RemoveVCProcess.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = RemoveVCProcess.cpp; path = code/RemoveVCProcess.cpp; sourceTree = SOURCE_ROOT; };
+		FB55283BC24C4A1CA86C4900 /* PolyTools.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = PolyTools.h; path = code/PolyTools.h; sourceTree = SOURCE_ROOT; };
+		FBC2BA7F2269489694BC890D /* FBXProperties.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = FBXProperties.h; path = code/FBXProperties.h; sourceTree = SOURCE_ROOT; };
+		FC0801BA1F95494498A089AF /* version.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = version.h; path = include/assimp/version.h; sourceTree = SOURCE_ROOT; };
+		FCCB4BB481FB461688FE2F29 /* B3DImporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = B3DImporter.cpp; path = code/B3DImporter.cpp; sourceTree = SOURCE_ROOT; };
+		FD84CFD1BD3E4AF4BA622BB8 /* MD2NormalTable.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MD2NormalTable.h; path = code/MD2NormalTable.h; sourceTree = SOURCE_ROOT; };
+		FD9BEC6B8A264AB092F98E20 /* SMDLoader.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = SMDLoader.cpp; path = code/SMDLoader.cpp; sourceTree = SOURCE_ROOT; };
+		FEEA39CDD7934999B89E2B4D /* MaterialSystem.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; name = MaterialSystem.h; path = code/MaterialSystem.h; sourceTree = SOURCE_ROOT; };
+		FF4E90FB1A3446F095ECC8BD /* Exporter.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; name = Exporter.cpp; path = code/Exporter.cpp; sourceTree = SOURCE_ROOT; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		7F79227D1AB43AC3005A8E5D /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		0117589D2B25420F831BA4CE /* MS3D */ = {
+			isa = PBXGroup;
+			children = (
+				A7A990C6FF244DC397B7BA7C /* MS3DLoader.cpp */,
+				6347FA5D391D4320B9457D3F /* MS3DLoader.h */,
+			);
+			name = MS3D;
+			sourceTree = "<group>";
+		};
+		0593669570C8417B8FE0C89E /* Obj */ = {
+			isa = PBXGroup;
+			children = (
+				DE811A81663A492A84E13937 /* ObjExporter.cpp */,
+				91EF6411C40946758A06144F /* ObjExporter.h */,
+				005DFE3B6FFC4BEBB7055330 /* ObjFileData.h */,
+				862131D4574B4CABA5EC957B /* ObjFileImporter.cpp */,
+				1FC965B1F11B45F98051C565 /* ObjFileImporter.h */,
+				4108529663904025B21E526B /* ObjFileMtlImporter.cpp */,
+				180177D50FDA4C10AD629DC2 /* ObjFileMtlImporter.h */,
+				ACF73EEAB2424213BF7158D5 /* ObjFileParser.cpp */,
+				333F4676A92043739F5A9D32 /* ObjFileParser.h */,
+				8FE8B4781BB3406EB3452154 /* ObjTools.h */,
+			);
+			name = Obj;
+			sourceTree = "<group>";
+		};
+		09D1759329AB410E92DC273A /* Collada */ = {
+			isa = PBXGroup;
+			children = (
+				1C0527629078403F81CFD117 /* ColladaExporter.cpp */,
+				638B3F6AC17A435C9B86C86C /* ColladaExporter.h */,
+				7C10178C0B7241DD874A0AF3 /* ColladaHelper.h */,
+				1A4706D216414D4F8AA72EC9 /* ColladaLoader.cpp */,
+				6981B16018CF46CAA54C0BAA /* ColladaLoader.h */,
+				420D77ED33554D54AA4D50EF /* ColladaParser.cpp */,
+				DC0210D3F25F470C86F914B3 /* ColladaParser.h */,
+			);
+			name = Collada;
+			sourceTree = "<group>";
+		};
+		0C22F81E750C429183194A1D /* Assxml */ = {
+			isa = PBXGroup;
+			children = (
+				B3E8A1BEF8E74F04AE06871B /* AssxmlExporter.cpp */,
+				F44E3625C31843B0AFA1A744 /* AssxmlExporter.h */,
+			);
+			name = Assxml;
+			sourceTree = "<group>";
+		};
+		1126F68352DC4FD49AC55DD7 /* ConvertUTF */ = {
+			isa = PBXGroup;
+			children = (
+				9A0960F123634603B15EEA38 /* ConvertUTF.c */,
+				6F88E78E61FC4A01BC30BE85 /* ConvertUTF.h */,
+			);
+			name = ConvertUTF;
+			sourceTree = "<group>";
+		};
+		16ED8F46E8ED44BAB8D7BA1B /* MaterialSystem */ = {
+			isa = PBXGroup;
+			children = (
+				7FF72CB6E99E40E19AE0E64C /* MaterialSystem.cpp */,
+				FEEA39CDD7934999B89E2B4D /* MaterialSystem.h */,
+			);
+			name = MaterialSystem;
+			sourceTree = "<group>";
+		};
+		1AC84A1DBE804A71B13E06C2 /* Clipper */ = {
+			isa = PBXGroup;
+			children = (
+				59F8A11A7AED45CC94CEDF28 /* clipper.cpp */,
+				C490BBF1881240EEA4A96315 /* clipper.hpp */,
+			);
+			name = Clipper;
+			sourceTree = "<group>";
+		};
+		1BF60AA5F4B147508EB44D8C /* Exporter */ = {
+			isa = PBXGroup;
+			children = (
+				A1A9535EDF9A4FF2B8DABD7D /* AssimpCExport.cpp */,
+				23097CBD64E343738B8F22EE /* BlobIOSystem.h */,
+				FF4E90FB1A3446F095ECC8BD /* Exporter.cpp */,
+			);
+			name = Exporter;
+			sourceTree = "<group>";
+		};
+		2B78DE034A954FAD96DA8432 /* IFC */ = {
+			isa = PBXGroup;
+			children = (
+				285D1FDA48EC4DD8933B603E /* IFCBoolean.cpp */,
+				2E7FD92FFCF441B0A60FC8B4 /* IFCCurve.cpp */,
+				3267EBBA6EEB435F83FF25E4 /* IFCGeometry.cpp */,
+				D0E9BB0220704C5D93CE7CE9 /* IFCLoader.cpp */,
+				2BE34AF1CE0C4767ACE21597 /* IFCLoader.h */,
+				0014AE5E87A74AAA9EF0EC4B /* IFCMaterial.cpp */,
+				74679D2078FD46ED9AC73355 /* IFCOpenings.cpp */,
+				46E9F455A3284DB399986293 /* IFCProfile.cpp */,
+				3F5D1E6368384D429BA29D5A /* IFCReaderGen.cpp */,
+				6162B57DE81A4E538430056E /* IFCReaderGen.h */,
+				59E3D32E3FC7438DB148537F /* IFCUtil.cpp */,
+				13BFADA520C04B15AE256CC2 /* IFCUtil.h */,
+				47FF3063906E4786ABF0939B /* STEPFile.h */,
+				E11A39E91576445599DF2AC4 /* STEPFileEncoding.cpp */,
+				D56A4C70F65D4E07BD792D2C /* STEPFileEncoding.h */,
+				CDE3ECA98173418A9F997992 /* STEPFileReader.cpp */,
+				A3D3024C3A59423487A125C8 /* STEPFileReader.h */,
+			);
+			name = IFC;
+			sourceTree = "<group>";
+		};
+		2CA4999D40FC406B97E1FFD3 /* Compiler */ = {
+			isa = PBXGroup;
+			children = (
+				FAC67CC462484F92A2CBD7D3 /* poppack1.h */,
+				278FB5C8BD814F2DAE04A1C7 /* pstdint.h */,
+				E81BAB0ED0854DDFA62CB956 /* pushpack1.h */,
+			);
+			name = Compiler;
+			sourceTree = "<group>";
+		};
+		2DC7AE369B84444B9649035D /* assimp */ = {
+			isa = PBXGroup;
+			children = (
+				DB181885BFCC44F594A1FA01 /* Source Files */,
+				628C9A9A9FA640B9AA1DAC09 /* Common */,
+				874C614E5BEB41419F0EEE1C /* Logging */,
+				1BF60AA5F4B147508EB44D8C /* Exporter */,
+				D3013C8FC8034BC6859BC020 /* PostProcessing */,
+				9AC9FD0CD777436C9C7291FF /* 3DS */,
+				98D9A21F310D47DD8F390780 /* AC */,
+				CB3420FADCED418CACDBB584 /* ASE */,
+				A7F45F8E82C445EBA7D67C36 /* Assbin */,
+				0C22F81E750C429183194A1D /* Assxml */,
+				A1E04517F0D440CDB46985A7 /* B3D */,
+				91C8DA33C37E491BBAD264C5 /* BVH */,
+				09D1759329AB410E92DC273A /* Collada */,
+				5F3147F7FF1044D49A824DBC /* DXF */,
+				DD5B35196B184EFB820D1FBB /* CSM */,
+				723B9CB1C871444FBB302576 /* HMP */,
+				6CB3C1AECE8A4745861D913D /* Irr */,
+				873AA0EB80814B0A9461BB7E /* LWO */,
+				32F48CB0DF784B6BA63A5025 /* LWS */,
+				F9261D592F00437EAFC663B5 /* MD2 */,
+				7D3FF9CAC50E41F0B59B9758 /* MD3 */,
+				97326C49E0E34D43AE80F0FF /* MD5 */,
+				CB981D90CEF4472191978170 /* MDC */,
+				EF7D37EB84AF45FC8BF47E7F /* MDL */,
+				16ED8F46E8ED44BAB8D7BA1B /* MaterialSystem */,
+				CF7D1A0DBB134AC4BCFE3C3F /* NFF */,
+				8438F0F891674542AF8F2302 /* OFFFormat */,
+				0593669570C8417B8FE0C89E /* Obj */,
+				6D12DDA749D645C68DBED62E /* Ogre */,
+				7FBE9FE41B65ABEF00D2115E /* OpenGEX */,
+				462ED039D874460E97B08346 /* Ply */,
+				F0273EDFDBD34EDAA6678613 /* Q3D */,
+				C3D412701D614559B698CED1 /* Q3BSP */,
+				9A8E68D1ECFC49B9BB435F1C /* Raw */,
+				8C2B1B7516DD4C4798F5048F /* SMD */,
+				2E29D94CA6DA405EB4AF90E0 /* STL */,
+				3A5EB041B5CD4F98802B2540 /* Terragen */,
+				8565C30231D64E81BB2B4ECD /* Unreal */,
+				96A36CD42ADB4BBBB54004E1 /* XFile */,
+				6E21649785DD4DB08D9A505D /* Extra */,
+				0117589D2B25420F831BA4CE /* MS3D */,
+				DAFF6641A88441AFBE8B99B1 /* COB */,
+				71D6A260C79746D3B50849D2 /* BLENDER */,
+				71199EE27B264D74B9D0A1C2 /* NDO */,
+				2B78DE034A954FAD96DA8432 /* IFC */,
+				2FC31A6272B94FB681FB8087 /* XGL */,
+				7F21D60E8DCD4C65923BD76C /* FBX */,
+				6B385D1E46704FB7BABB2D90 /* IrrXML */,
+				1126F68352DC4FD49AC55DD7 /* ConvertUTF */,
+				8B032622745B45FDB154A53C /* unzip */,
+				F61A479614764D11AC3311A8 /* Poly2Tri */,
+				1AC84A1DBE804A71B13E06C2 /* Clipper */,
+				3B11CB13DD484F938D3E3792 /* Boost */,
+				FCFE51BCE7384933A972EDEE /* Header Files */,
+				2CA4999D40FC406B97E1FFD3 /* Compiler */,
+			);
+			name = assimp;
+			sourceTree = "<group>";
+		};
+		2E29D94CA6DA405EB4AF90E0 /* STL */ = {
+			isa = PBXGroup;
+			children = (
+				89D2D359BD854D8AA60CB720 /* STLExporter.cpp */,
+				88ADA502481B403191BD35F0 /* STLExporter.h */,
+				4D2F1605B9484B08BB33402D /* STLLoader.cpp */,
+				C6D3C3E2BA2F49F2B17E7580 /* STLLoader.h */,
+			);
+			name = STL;
+			sourceTree = "<group>";
+		};
+		2FC31A6272B94FB681FB8087 /* XGL */ = {
+			isa = PBXGroup;
+			children = (
+				8E395349546A4FDF843E6963 /* XGLLoader.cpp */,
+				501B18C2B590455D8A3C3E78 /* XGLLoader.h */,
+			);
+			name = XGL;
+			sourceTree = "<group>";
+		};
+		32F48CB0DF784B6BA63A5025 /* LWS */ = {
+			isa = PBXGroup;
+			children = (
+				AFF41974881F466A9561BE4B /* LWSLoader.cpp */,
+				68703F99581F49CB9E2B9F37 /* LWSLoader.h */,
+			);
+			name = LWS;
+			sourceTree = "<group>";
+		};
+		3A5EB041B5CD4F98802B2540 /* Terragen */ = {
+			isa = PBXGroup;
+			children = (
+				4866DA5A7BFD49F79B61CBF8 /* TerragenLoader.cpp */,
+				815702BED5644DD5B242F347 /* TerragenLoader.h */,
+			);
+			name = Terragen;
+			sourceTree = "<group>";
+		};
+		3B11CB13DD484F938D3E3792 /* Boost */ = {
+			isa = PBXGroup;
+			children = (
+				AAD3EA9B0BB84A788FCCA83E /* foreach.hpp */,
+				1DC56C794E434BA28E5CCC36 /* format.hpp */,
+				96A02CBA1AE642BD9519719D /* make_shared.hpp */,
+				967D69AC1A344D4E988F0B2C /* common_factor_rt.hpp */,
+				C2C9EAC9B5B74AC397B070E8 /* scoped_array.hpp */,
+				7644CE6B26D740258577EE9D /* scoped_ptr.hpp */,
+				8C9AEFFFF3B948148D32D76F /* shared_array.hpp */,
+				3E84DEFC1E0646AD82F79998 /* shared_ptr.hpp */,
+				DFF8AF202CAA40E69D1A2BD0 /* static_assert.hpp */,
+				A7CEBC6894424B888326CAB2 /* tuple.hpp */,
+			);
+			name = Boost;
+			sourceTree = "<group>";
+		};
+		462ED039D874460E97B08346 /* Ply */ = {
+			isa = PBXGroup;
+			children = (
+				E51043448F1744FFA78526D5 /* PlyExporter.cpp */,
+				CC5D5CA1789448E9869B9669 /* PlyExporter.h */,
+				409C98EE093C499B8A574CA9 /* PlyLoader.cpp */,
+				91D49B3C51684882A01EA492 /* PlyLoader.h */,
+				2C4D504725E540109530E254 /* PlyParser.cpp */,
+				45F6A2B351AB4B749E55B299 /* PlyParser.h */,
+			);
+			name = Ply;
+			sourceTree = "<group>";
+		};
+		5F3147F7FF1044D49A824DBC /* DXF */ = {
+			isa = PBXGroup;
+			children = (
+				B6982D8069A145E5B9F97684 /* DXFHelper.h */,
+				466D6B9A7CCD402D9AA87071 /* DXFLoader.cpp */,
+				7BDF90B124F74A39A5EB3B02 /* DXFLoader.h */,
+			);
+			name = DXF;
+			sourceTree = "<group>";
+		};
+		628C9A9A9FA640B9AA1DAC09 /* Common */ = {
+			isa = PBXGroup;
+			children = (
+				A58410FEAA884A2D8D73ACCE /* BaseImporter.cpp */,
+				32170F499DAC4E4595AF6D6B /* BaseImporter.h */,
+				FAB6BC13FCFE40F5801D0972 /* BaseProcess.cpp */,
+				F468200042534D7CA2C9D891 /* BaseProcess.h */,
+				10238FBD7A9D401A82D667CB /* Bitmap.cpp */,
+				49AFF879142C4BA4865843DC /* Bitmap.h */,
+				339E56B5FD264481BBF21835 /* CInterfaceIOWrapper.h */,
+				F9FEF4D69EFC4605A4F752E5 /* DefaultIOStream.cpp */,
+				32CC68350B7640ACA7C83DDA /* DefaultIOStream.h */,
+				1D502654EF864101A2DA9476 /* DefaultIOSystem.cpp */,
+				D9AB66BD27E246A18091626F /* DefaultIOSystem.h */,
+				B7192C50B16142398B7CD221 /* DefaultProgressHandler.h */,
+				3ACFF3FC39C74C4A966C0FEA /* GenericProperty.h */,
+				9C5E3F9248B64C7EBF20EC27 /* Hash.h */,
+				6AC645CEB6F74AE5A62DF68B /* IFF.h */,
+				9472EFB6831740DD91471337 /* Importer.cpp */,
+				F81AE18E4AA94F9597FCB040 /* Importer.h */,
+				D029CE902F8045B0B3AFFDDB /* ImporterRegistry.cpp */,
+				680FBD79376A41B690C405B8 /* LineSplitter.h */,
+				D82B5BA87B184532BE74D24F /* LogAux.h */,
+				7DC4B0B5E57F4F4892CC823E /* MemoryIOWrapper.h */,
+				0C1B00249A554394A4F9CF2A /* ParsingUtils.h */,
+				E663847651834244834CB9F5 /* PostStepRegistry.cpp */,
+				5C1EA03E3AE24AA5A778B7F1 /* Profiler.h */,
+				6A86069DEEDC42B88634F78D /* RemoveComments.cpp */,
+				B4086213AE40445F817FA840 /* RemoveComments.h */,
+				52836A0629E24447B924750A /* SGSpatialSort.cpp */,
+				8299401C3E4A43A18E887DC1 /* SGSpatialSort.h */,
+				73A3D87FF2C04C3BA3684F54 /* SceneCombiner.cpp */,
+				8476FEE874C1404B9B4B9617 /* SceneCombiner.h */,
+				1775DE08FC8647EB896A0FB3 /* ScenePreprocessor.cpp */,
+				4FE1E4726B144AD1B922A1A0 /* ScenePreprocessor.h */,
+				97914BDA4AA34081855BF16C /* ScenePrivate.h */,
+				9B2827B3E64147E08A5AD334 /* SkeletonMeshBuilder.cpp */,
+				45BC2EB74251493CBBFAEB5D /* SkeletonMeshBuilder.h */,
+				2DCF6F156A3A4B4C807E5368 /* SmoothingGroups.h */,
+				8EEC6646FC044D1E9658A590 /* SpatialSort.cpp */,
+				957FBC18FED2484F83308E36 /* SpatialSort.h */,
+				99A4349D505F4CC593F48CF6 /* SplitByBoneCountProcess.cpp */,
+				B211101B342C414A9E43B7BC /* SplitByBoneCountProcess.h */,
+				C18C5023460E4D17B8C922D7 /* StandardShapes.cpp */,
+				296407DE471C4F298742FB59 /* StandardShapes.h */,
+				ED20428B31DF46C6A9D65322 /* StreamReader.h */,
+				7E8BA0D338C9433587BC6C35 /* StreamWriter.h */,
+				BDD30C77BB68497EA3B7F2F7 /* StringComparison.h */,
+				4BBDEB63CFEB4F2EAA95358D /* Subdivision.cpp */,
+				A72115ED828F4069A427B460 /* Subdivision.h */,
+				6F65B6129F774AEDB8DC845A /* TargetAnimation.cpp */,
+				A7733823362B4A389102D177 /* TargetAnimation.h */,
+				E01801CB159D47928B3D96B5 /* TinyFormatter.h */,
+				1533BE4C09F1430C8BF4D248 /* Vertex.h */,
+				0AAF26EBF0A64ABDB840BA64 /* VertexTriangleAdjacency.cpp */,
+				F4AE5F74C20B400EA688B5ED /* VertexTriangleAdjacency.h */,
+				DC67FF8B4313494F8C03D840 /* XMLTools.h */,
+				1AF1EE8EFE594A40ACE03D19 /* fast_atof.h */,
+				262DFE65C6D34442AA79D15A /* qnan.h */,
+			);
+			name = Common;
+			sourceTree = "<group>";
+		};
+		6B385D1E46704FB7BABB2D90 /* IrrXML */ = {
+			isa = PBXGroup;
+			children = (
+				D1073FF20359469D921C9316 /* irrXMLWrapper.h */,
+				D40F70AC841D4B788B5C696B /* CXMLReaderImpl.h */,
+				02587469A85540EE875B04B5 /* heapsort.h */,
+				49FE5C30FC854A3EBD0E9C19 /* irrArray.h */,
+				5D4E64EABD9548A59E9637AF /* irrString.h */,
+				4936396409984881858E7B15 /* irrTypes.h */,
+				64C6BACDA5DD4139AA26EE81 /* irrXML.cpp */,
+				12E167EBA81B4CD3A241D7AF /* irrXML.h */,
+			);
+			name = IrrXML;
+			sourceTree = "<group>";
+		};
+		6CB3C1AECE8A4745861D913D /* Irr */ = {
+			isa = PBXGroup;
+			children = (
+				97DFA90F9D0C4B999C150B10 /* IRRLoader.cpp */,
+				1011FC45108745A7BBA98904 /* IRRLoader.h */,
+				DD7FFD53046F4AEB898C0832 /* IRRMeshLoader.cpp */,
+				670FE6DD7EDF421488F2F97F /* IRRMeshLoader.h */,
+				CC54A231FF6B4B0CABCFD167 /* IRRShared.cpp */,
+				B04FE3598E344EC09B59CA2F /* IRRShared.h */,
+			);
+			name = Irr;
+			sourceTree = "<group>";
+		};
+		6D12DDA749D645C68DBED62E /* Ogre */ = {
+			isa = PBXGroup;
+			children = (
+				56ADEC4899C047F2839AD791 /* OgreBinarySerializer.cpp */,
+				916456789C75419DB1436FAD /* OgreBinarySerializer.h */,
+				923283A9791E4B4E86D623FC /* OgreImporter.cpp */,
+				71F65BF6936E4E97A5933EF9 /* OgreImporter.h */,
+				F75457C6D026451B9267B65E /* OgreMaterial.cpp */,
+				6F49958B5CCF423681133515 /* OgreParsingUtils.h */,
+				79A49EFE23E34E1CBA2E4377 /* OgreStructs.cpp */,
+				F8B1133805564E18B32FFA83 /* OgreStructs.h */,
+				EF9F805A4BA4428CA98C9DE5 /* OgreXmlSerializer.cpp */,
+				AC699876B6364EC1878CBA44 /* OgreXmlSerializer.h */,
+			);
+			name = Ogre;
+			sourceTree = "<group>";
+		};
+		6E21649785DD4DB08D9A505D /* Extra */ = {
+			isa = PBXGroup;
+			children = (
+				00EB692107B84590B0560BFB /* MD4FileData.h */,
+			);
+			name = Extra;
+			sourceTree = "<group>";
+		};
+		71199EE27B264D74B9D0A1C2 /* NDO */ = {
+			isa = PBXGroup;
+			children = (
+				B4F1B5789CA540C78FB9219D /* NDOLoader.cpp */,
+				37A3E0E2BB484DD8B9FCCA5E /* NDOLoader.h */,
+			);
+			name = NDO;
+			sourceTree = "<group>";
+		};
+		71D6A260C79746D3B50849D2 /* BLENDER */ = {
+			isa = PBXGroup;
+			children = (
+				603AFA882AFF49AEAC2C8FA2 /* BlenderBMesh.cpp */,
+				4568875B66584E12AA1538C7 /* BlenderBMesh.h */,
+				B65258E349704523BC43904D /* BlenderDNA.cpp */,
+				72832410F47C44E3BAE709C2 /* BlenderDNA.h */,
+				43899EB0B0704A9DB8F0C54F /* BlenderDNA.inl */,
+				7CAF8A3096E04CB983B53CC1 /* BlenderIntermediate.h */,
+				906F71D342544BF381E1318E /* BlenderLoader.cpp */,
+				157C3CC81232428FA535E05F /* BlenderLoader.h */,
+				3106D75C13874F5AB3EBBFE7 /* BlenderModifier.cpp */,
+				F5720C42345840CB9FEA5A40 /* BlenderModifier.h */,
+				DE0D259917354C80BE1CC791 /* BlenderScene.cpp */,
+				B522B83A39CA461CBCABE25A /* BlenderScene.h */,
+				76D801D898C4443D8240EDB7 /* BlenderSceneGen.h */,
+				12C5DD7A285042EDB1897FAE /* BlenderTessellator.cpp */,
+				59A1859480754E90B958CA85 /* BlenderTessellator.h */,
+			);
+			name = BLENDER;
+			sourceTree = "<group>";
+		};
+		723B9CB1C871444FBB302576 /* HMP */ = {
+			isa = PBXGroup;
+			children = (
+				71EAFDE1910B4A54AAAF2101 /* HMPFileData.h */,
+				43ABFF591F374920A5E18A24 /* HMPLoader.cpp */,
+				5631CE86F56F458EA0E2415F /* HMPLoader.h */,
+				7C63156710964DEDAC0929BD /* HalfLifeFileData.h */,
+			);
+			name = HMP;
+			sourceTree = "<group>";
+		};
+		7D3FF9CAC50E41F0B59B9758 /* MD3 */ = {
+			isa = PBXGroup;
+			children = (
+				08E8379F20984AD59515AD95 /* MD3FileData.h */,
+				563FBACCFD774BDEA4AEAC10 /* MD3Loader.cpp */,
+				1CBCEE37D89145F19F23F036 /* MD3Loader.h */,
+			);
+			name = MD3;
+			sourceTree = "<group>";
+		};
+		7F21D60E8DCD4C65923BD76C /* FBX */ = {
+			isa = PBXGroup;
+			children = (
+				EAD34F1AA6664B6B935C9421 /* FBXAnimation.cpp */,
+				1108AC28566B4D2B9F27C691 /* FBXBinaryTokenizer.cpp */,
+				26BF681530B04B73961997CB /* FBXCompileConfig.h */,
+				A7A56A688A3845768410F500 /* FBXConverter.cpp */,
+				A7A86F81858F4D928A568E17 /* FBXConverter.h */,
+				9855496CEA774F4FA7FBB862 /* FBXDeformer.cpp */,
+				F22D5BA425444A028DA42BEA /* FBXDocument.cpp */,
+				0EF256EC06E345EB930772EC /* FBXDocument.h */,
+				BB38E7E7661842448F008372 /* FBXDocumentUtil.cpp */,
+				C17C5037C995420C8D259C0C /* FBXImportSettings.h */,
+				B4C688FA08F44716855CDD3C /* FBXImporter.cpp */,
+				AA4946AEDB9F4F22873C4C4F /* FBXImporter.h */,
+				EE6163EB035149A6B8139DB8 /* FBXMaterial.cpp */,
+				42E110B9E6924AF9B55AE65A /* FBXMeshGeometry.cpp */,
+				1A61BDC559CE4186B03C0396 /* FBXModel.cpp */,
+				33B70115CA54405F895BA471 /* FBXNodeAttribute.cpp */,
+				5F373DF3B03B4B848B78EAD2 /* FBXParser.cpp */,
+				F8AC3A243B9C47D6B31348BA /* FBXParser.h */,
+				9D203F78B24C4D7E8E2084A3 /* FBXProperties.cpp */,
+				FBC2BA7F2269489694BC890D /* FBXProperties.h */,
+				CF07D05DC86F4C98BC42FDCF /* FBXTokenizer.cpp */,
+				E7E85BF696E74CFAAEBF895C /* FBXTokenizer.h */,
+				E6332CD992D447CA910DA456 /* FBXUtil.cpp */,
+				89473420F7E448A7BE71FCBA /* FBXUtil.h */,
+			);
+			name = FBX;
+			sourceTree = "<group>";
+		};
+		7F392D931AB2C7C200D952EB /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				7F29EF981AB26C4900E9D380 /* libz.1.dylib */,
+				7F392D921AB2C7BB00D952EB /* libc++.dylib */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		7FBE9FE41B65ABEF00D2115E /* OpenGEX */ = {
+			isa = PBXGroup;
+			children = (
+				7FBE9FE51B65AC1200D2115E /* OpenGEXExporter.cpp */,
+				7FBE9FE61B65AC1200D2115E /* OpenGEXExporter.h */,
+				7FBE9FE71B65AC1200D2115E /* OpenGEXImporter.cpp */,
+				7FBE9FE81B65AC1200D2115E /* OpenGEXImporter.h */,
+				7FBE9FE91B65AC1200D2115E /* OpenGEXStructs.h */,
+				7FBEA0051B65AF8900D2115E /* openddlparser */,
+			);
+			name = OpenGEX;
+			sourceTree = "<group>";
+		};
+		7FBEA0051B65AF8900D2115E /* openddlparser */ = {
+			isa = PBXGroup;
+			children = (
+				7FBEA0081B65AF9200D2115E /* OpenDDLCommon.h */,
+				7FBEA00B1B65AF9200D2115E /* OpenDDLParserUtils.h */,
+				7FBEA0071B65AF9200D2115E /* DDLNode.h */,
+				7F7A93A51B65D0110094C4DA /* DDLNode.cpp */,
+				7FBEA00A1B65AF9200D2115E /* OpenDDLParser.h */,
+				7F7A93A61B65D0110094C4DA /* OpenDDLParser.cpp */,
+				7FBEA00D1B65AF9200D2115E /* Value.h */,
+				7F7A93A71B65D0110094C4DA /* Value.cpp */,
+			);
+			name = openddlparser;
+			sourceTree = "<group>";
+		};
+		8438F0F891674542AF8F2302 /* OFFFormat */ = {
+			isa = PBXGroup;
+			children = (
+				EFD557FE2C3A46D78F070655 /* OFFLoader.cpp */,
+				BF94F50C216B45388CDEC1EF /* OFFLoader.h */,
+			);
+			name = OFFFormat;
+			sourceTree = "<group>";
+		};
+		8565C30231D64E81BB2B4ECD /* Unreal */ = {
+			isa = PBXGroup;
+			children = (
+				3B8FD96D46314ACD8F157AC3 /* UnrealLoader.cpp */,
+				27F2019E621B4CDA94DD5270 /* UnrealLoader.h */,
+			);
+			name = Unreal;
+			sourceTree = "<group>";
+		};
+		873AA0EB80814B0A9461BB7E /* LWO */ = {
+			isa = PBXGroup;
+			children = (
+				680C392FFE0B4CC5ABC7CA64 /* LWOAnimation.cpp */,
+				A14347E954E8413CAF1455EA /* LWOAnimation.h */,
+				D629F6BF53864979B7619067 /* LWOBLoader.cpp */,
+				AFA8B6DE5B3A4E52A85041C9 /* LWOFileData.h */,
+				5A4E05386C094B809A315A07 /* LWOLoader.cpp */,
+				72F2DF0B93CF4D3ABAD7513D /* LWOLoader.h */,
+				1ED21FC57A384CE6B4F53C0C /* LWOMaterial.cpp */,
+			);
+			name = LWO;
+			sourceTree = "<group>";
+		};
+		874C614E5BEB41419F0EEE1C /* Logging */ = {
+			isa = PBXGroup;
+			children = (
+				A9E9EB834E09420197C3FB8C /* DefaultLogger.cpp */,
+				1520A11AA6E54812939B1FBB /* FileLogStream.h */,
+				4CBC1122A79D4F6C94E36CE3 /* StdOStreamLogStream.h */,
+				F4BA09C943DD49E184316D97 /* Win32DebugLogStream.h */,
+				D958B0B445E64F4BA9145D82 /* DefaultLogger.hpp */,
+				657B9A15EE7A4B7BA519A969 /* LogStream.hpp */,
+				56CE07D64D114C4BAB6D9F08 /* Logger.hpp */,
+				8D977E197CA4477AB9F3278C /* NullLogger.hpp */,
+			);
+			name = Logging;
+			sourceTree = "<group>";
+		};
+		8B032622745B45FDB154A53C /* unzip */ = {
+			isa = PBXGroup;
+			children = (
+				A4CBF9157F01460ABEDEBF28 /* crypt.h */,
+				AF75E6049338489BB256D295 /* ioapi.c */,
+				72F637AC7D9E4FBFBB9201CE /* ioapi.h */,
+				973D4231A4AA4925B019FEEE /* unzip.c */,
+				9293C5A353F9497A850E05D5 /* unzip.h */,
+			);
+			name = unzip;
+			sourceTree = "<group>";
+		};
+		8C2B1B7516DD4C4798F5048F /* SMD */ = {
+			isa = PBXGroup;
+			children = (
+				FD9BEC6B8A264AB092F98E20 /* SMDLoader.cpp */,
+				C582480917FF4EB09C164D70 /* SMDLoader.h */,
+			);
+			name = SMD;
+			sourceTree = "<group>";
+		};
+		91C8DA33C37E491BBAD264C5 /* BVH */ = {
+			isa = PBXGroup;
+			children = (
+				C80B9A3AF4204AE08AA50BAE /* BVHLoader.cpp */,
+				45E342A1499E4F03ADD49028 /* BVHLoader.h */,
+			);
+			name = BVH;
+			sourceTree = "<group>";
+		};
+		96A36CD42ADB4BBBB54004E1 /* XFile */ = {
+			isa = PBXGroup;
+			children = (
+				435DC362E63D4CCBA68656D3 /* XFileExporter.cpp */,
+				A257229A058041389981CFC1 /* XFileExporter.h */,
+				8F4261792A60481DA04E6E1A /* XFileHelper.h */,
+				06DB494DCE4D47FDA00E8B35 /* XFileImporter.cpp */,
+				53537D08E9B44A25B43B697B /* XFileImporter.h */,
+				74C02A113B804568A7E39CBC /* XFileParser.cpp */,
+				3551D90CCED1454A8B912066 /* XFileParser.h */,
+			);
+			name = XFile;
+			sourceTree = "<group>";
+		};
+		97326C49E0E34D43AE80F0FF /* MD5 */ = {
+			isa = PBXGroup;
+			children = (
+				A277DBC1EFB944F995659A20 /* MD5Loader.cpp */,
+				6BAB32C8E06E43689FC5E7EA /* MD5Loader.h */,
+				0BC5FD00572F4C58B267A0EC /* MD5Parser.cpp */,
+				43FC808D2F4745ACB06A9D33 /* MD5Parser.h */,
+			);
+			name = MD5;
+			sourceTree = "<group>";
+		};
+		98D9A21F310D47DD8F390780 /* AC */ = {
+			isa = PBXGroup;
+			children = (
+				F1076BAC69DB4935A93045A8 /* ACLoader.cpp */,
+				4DABF3CB245F4246B0184513 /* ACLoader.h */,
+			);
+			name = AC;
+			sourceTree = "<group>";
+		};
+		9A8E68D1ECFC49B9BB435F1C /* Raw */ = {
+			isa = PBXGroup;
+			children = (
+				1D4A669762194B9D9A26DD20 /* RawLoader.cpp */,
+				EAD338BE19AE4C2E897B38B6 /* RawLoader.h */,
+			);
+			name = Raw;
+			sourceTree = "<group>";
+		};
+		9AC9FD0CD777436C9C7291FF /* 3DS */ = {
+			isa = PBXGroup;
+			children = (
+				15221A74FC9C4B2AAA7306E3 /* 3DSConverter.cpp */,
+				ECCBBF2D75A44335AB93C84A /* 3DSExporter.cpp */,
+				0B519CCAB4B241E59C567077 /* 3DSExporter.h */,
+				CB042D863BD447FFB117AE34 /* 3DSHelper.h */,
+				02E9476D129940BF84DE6682 /* 3DSLoader.cpp */,
+				A06CBE89CFAB48E786F7A5C0 /* 3DSLoader.h */,
+			);
+			name = 3DS;
+			sourceTree = "<group>";
+		};
+		A1E04517F0D440CDB46985A7 /* B3D */ = {
+			isa = PBXGroup;
+			children = (
+				FCCB4BB481FB461688FE2F29 /* B3DImporter.cpp */,
+				42E68041B1C442E3B49FC304 /* B3DImporter.h */,
+			);
+			name = B3D;
+			sourceTree = "<group>";
+		};
+		A7F45F8E82C445EBA7D67C36 /* Assbin */ = {
+			isa = PBXGroup;
+			children = (
+				6389F68312384CFD847B1D13 /* AssbinExporter.cpp */,
+				6CC21F1D0E4140FE923E4EE6 /* AssbinExporter.h */,
+				D9FEEF58B24548F782A5D53C /* AssbinLoader.cpp */,
+				0CCD090F58EB40ACBBDBBDEE /* AssbinLoader.h */,
+			);
+			name = Assbin;
+			sourceTree = "<group>";
+		};
+		AF05BC16567A496BB5DCB2F0 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				7F7922801AB43AC3005A8E5D /* libassimp.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		BCC52F1D5AF74E54A2D69524 = {
+			isa = PBXGroup;
+			children = (
+				2DC7AE369B84444B9649035D /* assimp */,
+				7F392D931AB2C7C200D952EB /* Frameworks */,
+				AF05BC16567A496BB5DCB2F0 /* Products */,
+			);
+			sourceTree = "<group>";
+		};
+		C3D412701D614559B698CED1 /* Q3BSP */ = {
+			isa = PBXGroup;
+			children = (
+				6E82409E9D274D278971F3B0 /* Q3BSPFileData.h */,
+				A88D56FBEA084A3EA9A0ECB3 /* Q3BSPFileImporter.cpp */,
+				F898EEA0D9E64425A790587D /* Q3BSPFileImporter.h */,
+				4A60A00727F04E049CF3AE33 /* Q3BSPFileParser.cpp */,
+				5C15EEB253204E8A8E0D0E38 /* Q3BSPFileParser.h */,
+				43C75175738C4119871E8BB0 /* Q3BSPZipArchive.cpp */,
+				6454A961FAF44B3E9086D2F8 /* Q3BSPZipArchive.h */,
+			);
+			name = Q3BSP;
+			sourceTree = "<group>";
+		};
+		CB3420FADCED418CACDBB584 /* ASE */ = {
+			isa = PBXGroup;
+			children = (
+				7C477FA4D89548F1BCEDC5A0 /* ASELoader.cpp */,
+				9A61AF384D4D45778698DD7D /* ASELoader.h */,
+				929F59CCA32549EC884A5033 /* ASEParser.cpp */,
+				27605E75944D41B0B98260A3 /* ASEParser.h */,
+			);
+			name = ASE;
+			sourceTree = "<group>";
+		};
+		CB981D90CEF4472191978170 /* MDC */ = {
+			isa = PBXGroup;
+			children = (
+				95641498F25A4F6FABBC03A4 /* MDCFileData.h */,
+				35E4944C052A4C91BF31DE5F /* MDCLoader.cpp */,
+				621E96E95F60421EB6B4525C /* MDCLoader.h */,
+				DD4E4641B0FE4369BF3775C3 /* MDCNormalTable.h */,
+			);
+			name = MDC;
+			sourceTree = "<group>";
+		};
+		CF7D1A0DBB134AC4BCFE3C3F /* NFF */ = {
+			isa = PBXGroup;
+			children = (
+				0D6E8E292F594A2DAFF53564 /* NFFLoader.cpp */,
+				D2869C6AD4814588A45E8F81 /* NFFLoader.h */,
+			);
+			name = NFF;
+			sourceTree = "<group>";
+		};
+		D3013C8FC8034BC6859BC020 /* PostProcessing */ = {
+			isa = PBXGroup;
+			children = (
+				90DD6CA40A5E41458E11FF3E /* CalcTangentsProcess.cpp */,
+				BBEE1CF81183473C8492FC03 /* CalcTangentsProcess.h */,
+				2ABBB4561E72413EB40702C3 /* ComputeUVMappingProcess.cpp */,
+				B40FE1BF9D8E411493BBDE0C /* ComputeUVMappingProcess.h */,
+				92D8734FFF9742B39A371B70 /* ConvertToLHProcess.cpp */,
+				35A9B50143214C63A956FA27 /* ConvertToLHProcess.h */,
+				6E20FCC571F144DDBD831CCB /* DeboneProcess.cpp */,
+				4770D6DCA1854B4F9B85546A /* DeboneProcess.h */,
+				BABB7734139C452A9DDEE797 /* FindDegenerates.cpp */,
+				4B571231CE2B464BBF1E853F /* FindDegenerates.h */,
+				C9A101D1311C4E77AAEDD94C /* FindInstancesProcess.cpp */,
+				28A938B21261484998F68F4A /* FindInstancesProcess.h */,
+				9B4221AA0AD2418FAA45EB64 /* FindInvalidDataProcess.cpp */,
+				91FF8B1DCC0644008AE34A04 /* FindInvalidDataProcess.h */,
+				C54518F708BA4A328D5D7325 /* FixNormalsStep.cpp */,
+				8343910BBD464297932B3CE0 /* FixNormalsStep.h */,
+				982AE676D2364350B1FBD095 /* GenFaceNormalsProcess.cpp */,
+				0FBF026F27F340AD9FABAF02 /* GenFaceNormalsProcess.h */,
+				A0AED12A1A6D4635A8CFB65A /* GenVertexNormalsProcess.cpp */,
+				2AC344FBB0C34D49800F4B8A /* GenVertexNormalsProcess.h */,
+				70D5FDFA995E45E6A3E8FD37 /* ImproveCacheLocality.cpp */,
+				5FBE72DCC6AC485ABCF89B8C /* ImproveCacheLocality.h */,
+				B36DA471B9E142FC9425EC45 /* JoinVerticesProcess.cpp */,
+				0A941971CBF04E8D900E9799 /* JoinVerticesProcess.h */,
+				E065DB38B0284196A9283CA3 /* LimitBoneWeightsProcess.cpp */,
+				DDDE82BDF4F94E0EA35649A4 /* LimitBoneWeightsProcess.h */,
+				21B797DAB0E0427C9339AE0F /* MakeVerboseFormat.cpp */,
+				0AA53AD6095A4D1088431EED /* MakeVerboseFormat.h */,
+				AAB9AE5328F843F5A8A3E85C /* OptimizeGraph.cpp */,
+				926E8B7924144B349A88023D /* OptimizeGraph.h */,
+				2ACC87E846AE4E4A86E1AEF4 /* OptimizeMeshes.cpp */,
+				DD3D18BC2E58447D9879CB00 /* OptimizeMeshes.h */,
+				FB55283BC24C4A1CA86C4900 /* PolyTools.h */,
+				023C115651B54570AA2040DB /* PretransformVertices.cpp */,
+				101172E4EF2E43D988B6B571 /* PretransformVertices.h */,
+				890E32C714444692AA016AE5 /* ProcessHelper.cpp */,
+				A436C47FBF904FECB4A58462 /* ProcessHelper.h */,
+				ADACEBC4973F4FC0A6FEC68A /* RemoveRedundantMaterials.cpp */,
+				AD969BA482564C7FAA372F7C /* RemoveRedundantMaterials.h */,
+				FB4ABA17AF264257BDA4D921 /* RemoveVCProcess.cpp */,
+				ABDA70358E34432A8A4637F4 /* RemoveVCProcess.h */,
+				BD9A81E0E27E44718609615B /* SortByPTypeProcess.cpp */,
+				16437E08A946431EB2EFA3E0 /* SortByPTypeProcess.h */,
+				A43641DC9C1B4B578BC40476 /* SplitLargeMeshes.cpp */,
+				D2EEB62ECBF749AA89146C66 /* SplitLargeMeshes.h */,
+				DF76D04D95E649BCBC15E64F /* TextureTransform.cpp */,
+				C5C3ED2BE50D4684994BD533 /* TextureTransform.h */,
+				1A0AC303D18A48A69AB3BC03 /* TriangulateProcess.cpp */,
+				FB2510D46F504365A03EE8A8 /* TriangulateProcess.h */,
+				0EF4F7A237F648C2809A8F31 /* ValidateDataStructure.cpp */,
+				725DAD1CE04C4F64BDAB7037 /* ValidateDataStructure.h */,
+			);
+			name = PostProcessing;
+			sourceTree = "<group>";
+		};
+		DAFF6641A88441AFBE8B99B1 /* COB */ = {
+			isa = PBXGroup;
+			children = (
+				C84DA0E6CE13493D833BA1C1 /* COBLoader.cpp */,
+				445F70426FCC42F088405E86 /* COBLoader.h */,
+				9E0572B45F1F4605BD5C919D /* COBScene.h */,
+			);
+			name = COB;
+			sourceTree = "<group>";
+		};
+		DB181885BFCC44F594A1FA01 /* Source Files */ = {
+			isa = PBXGroup;
+			children = (
+				705D30EE141A48F292783F0E /* Assimp.cpp */,
+				7FBEA0111B65B11800D2115E /* Version.cpp */,
+			);
+			name = "Source Files";
+			sourceTree = "<group>";
+		};
+		DD5B35196B184EFB820D1FBB /* CSM */ = {
+			isa = PBXGroup;
+			children = (
+				77908990BEF04D0881E8AE80 /* CSMLoader.cpp */,
+				1BC6B0FE92DD4F38803BC17B /* CSMLoader.h */,
+			);
+			name = CSM;
+			sourceTree = "<group>";
+		};
+		EF7D37EB84AF45FC8BF47E7F /* MDL */ = {
+			isa = PBXGroup;
+			children = (
+				F1A7BD0B5CAE48699FCAEBD1 /* MDLDefaultColorMap.h */,
+				D5F4108F03D7457EB641836B /* MDLFileData.h */,
+				AA92FFC8B06D4569AD9C4CB1 /* MDLLoader.cpp */,
+				E24E950227C848D3A759F5C2 /* MDLLoader.h */,
+				CEC69808E1844C23B95D3475 /* MDLMaterialLoader.cpp */,
+			);
+			name = MDL;
+			sourceTree = "<group>";
+		};
+		F0273EDFDBD34EDAA6678613 /* Q3D */ = {
+			isa = PBXGroup;
+			children = (
+				C5178B3983F147F3B9BD8217 /* Q3DLoader.cpp */,
+				76773A53296549FFA43956A1 /* Q3DLoader.h */,
+			);
+			name = Q3D;
+			sourceTree = "<group>";
+		};
+		F61A479614764D11AC3311A8 /* Poly2Tri */ = {
+			isa = PBXGroup;
+			children = (
+				AE00939F150F413780C8AAD7 /* shapes.cc */,
+				EE545B58FA1246C792C6AD01 /* shapes.h */,
+				50935A81362041BEADF18609 /* utils.h */,
+				B72D0BA3EF66439F8D582ED3 /* advancing_front.cc */,
+				DAE82F651F9E4D91A6A6C753 /* advancing_front.h */,
+				849EC6315E4A4E5FA06521EA /* cdt.cc */,
+				904A696E49D540C2A880792B /* cdt.h */,
+				49E993CD86A346869AF473BC /* sweep.cc */,
+				62E8551653634972ABBABCAD /* sweep.h */,
+				5E10483FBE6D4F4594B460E0 /* sweep_context.cc */,
+				267D593135514108B7DEF072 /* sweep_context.h */,
+			);
+			name = Poly2Tri;
+			sourceTree = "<group>";
+		};
+		F9261D592F00437EAFC663B5 /* MD2 */ = {
+			isa = PBXGroup;
+			children = (
+				21E21BE7CB364AC3AB81E54C /* MD2FileData.h */,
+				49B655CCE1314D4E8A94B371 /* MD2Loader.cpp */,
+				531FBC4210644C61954EA4C4 /* MD2Loader.h */,
+				FD84CFD1BD3E4AF4BA622BB8 /* MD2NormalTable.h */,
+			);
+			name = MD2;
+			sourceTree = "<group>";
+		};
+		FCFE51BCE7384933A972EDEE /* Header Files */ = {
+			isa = PBXGroup;
+			children = (
+				731205CAB88247C095E33412 /* Exporter.hpp */,
+				B54FBAAF061B40DBA3F48F83 /* IOStream.hpp */,
+				86E296E459F94050ACBA3C63 /* IOSystem.hpp */,
+				B9DFF24FD63A4D9FAE213EED /* Importer.hpp */,
+				69AFF47737244CE3BD1653CC /* ProgressHandler.hpp */,
+				C7B37CA474DF4CE7A5B0658E /* ai_assert.h */,
+				B441D87EE6ED4EBFB0586B66 /* anim.h */,
+				B05DC38593F04180B322360B /* camera.h */,
+				2F34A6A3C4104625A52BF7C2 /* cexport.h */,
+				E1313C36045444619026E9FB /* cfileio.h */,
+				267A74499024423A86150697 /* cimport.h */,
+				0535CB113239433DA7CD7FDE /* color4.h */,
+				079B3C75D1014265959C427D /* color4.inl */,
+				90949C7A51E84D3595D71A6B /* config.h */,
+				9761D873B9604504B9AD7CD5 /* defs.h */,
+				4D82A29A8BBF44E69E026F84 /* importerdesc.h */,
+				8E2108F568374F65ACE217D1 /* light.h */,
+				05EA73C462244F1791039BFB /* material.h */,
+				139DFC029C4C44B09952C645 /* material.inl */,
+				10E9B0497D844A10BC759A09 /* matrix3x3.h */,
+				073189BEE7A5466B9EE817D4 /* matrix3x3.inl */,
+				BA832069DF214327AE067503 /* matrix4x4.h */,
+				4493838DDEE841BF96A0F008 /* matrix4x4.inl */,
+				E9ED3048A21E483F9C2721F4 /* mesh.h */,
+				5F84BDD0D5D345A2BF1E08E1 /* metadata.h */,
+				41C2F6D564924BF4ACE75CAC /* postprocess.h */,
+				279D2A482FE9402A8F7EC441 /* quaternion.h */,
+				97F52051AF4F478FA77AABBC /* quaternion.inl */,
+				3B407EAF162843CBA46BC9D4 /* scene.h */,
+				AE1C2E2C9C424B3684AD9D4A /* texture.h */,
+				56DA1CDC223747F4AFBAF953 /* types.h */,
+				FB1E84BE85A34F98A44BBB2B /* vector2.h */,
+				B6074B1E864740F787A97EA3 /* vector2.inl */,
+				6D72952403D04713A6451654 /* vector3.h */,
+				8D53CC35AAED4CE8B9710E04 /* vector3.inl */,
+				FC0801BA1F95494498A089AF /* version.h */,
+			);
+			name = "Header Files";
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		7F79227F1AB43AC3005A8E5D /* assimp */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 7F7922911AB43AC3005A8E5D /* Build configuration list for PBXNativeTarget "assimp" */;
+			buildPhases = (
+				7F79229B1AB43AF4005A8E5D /* Run Script to build "revision.h" */,
+				7F79227C1AB43AC3005A8E5D /* Sources */,
+				7F79227D1AB43AC3005A8E5D /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = assimp;
+			productName = assimp;
+			productReference = 7F7922801AB43AC3005A8E5D /* libassimp.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		9DE203BC835F4C81BCDF25CF /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				BuildIndependentTargetsInParallel = YES;
+				LastUpgradeCheck = 0700;
+				TargetAttributes = {
+					7F79227F1AB43AC3005A8E5D = {
+						CreatedOnToolsVersion = 6.3;
+					};
+				};
+			};
+			buildConfigurationList = 0C36C32B633D49CB92166176 /* Build configuration list for PBXProject "Assimp" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+			);
+			mainGroup = BCC52F1D5AF74E54A2D69524;
+			projectDirPath = ../..;
+			projectRoot = "";
+			targets = (
+				7F79227F1AB43AC3005A8E5D /* assimp */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXShellScriptBuildPhase section */
+		7F79229B1AB43AF4005A8E5D /* Run Script to build "revision.h" */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+			);
+			name = "Run Script to build \"revision.h\"";
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "mkdir -p \"${DERIVED_FILE_DIR}\"\ncat \"${SRCROOT}/revision.h.in\" | sed \"s/@GIT_COMMIT_HASH@/`git rev-parse --short HEAD`/g\" | sed \"s/@GIT_BRANCH@/`git rev-parse --abbrev-ref HEAD`/g\" > \"${DERIVED_FILE_DIR}/revision.h\"";
+			showEnvVarsInLog = 0;
+		};
+/* End PBXShellScriptBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		7F79227C1AB43AC3005A8E5D /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				7F79242A1AB43E20005A8E5D /* 3DSConverter.cpp in Sources */,
+				7F79242B1AB43E20005A8E5D /* 3DSExporter.cpp in Sources */,
+				7F79242C1AB43E20005A8E5D /* 3DSLoader.cpp in Sources */,
+				7F79242D1AB43E20005A8E5D /* ACLoader.cpp in Sources */,
+				7F79242E1AB43E20005A8E5D /* ASELoader.cpp in Sources */,
+				7F79242F1AB43E20005A8E5D /* ASEParser.cpp in Sources */,
+				7F7924301AB43E20005A8E5D /* AssbinExporter.cpp in Sources */,
+				7F7924311AB43E20005A8E5D /* AssbinLoader.cpp in Sources */,
+				7F7924321AB43E20005A8E5D /* Assimp.cpp in Sources */,
+				7F7924331AB43E20005A8E5D /* AssimpCExport.cpp in Sources */,
+				7F7924351AB43E20005A8E5D /* AssxmlExporter.cpp in Sources */,
+				7F7924361AB43E20005A8E5D /* B3DImporter.cpp in Sources */,
+				7F7924371AB43E20005A8E5D /* BVHLoader.cpp in Sources */,
+				7F7924381AB43E20005A8E5D /* BaseImporter.cpp in Sources */,
+				7F7924391AB43E20005A8E5D /* BaseProcess.cpp in Sources */,
+				7F79243A1AB43E20005A8E5D /* Bitmap.cpp in Sources */,
+				7F79243B1AB43E20005A8E5D /* BlenderBMesh.cpp in Sources */,
+				7F79243C1AB43E20005A8E5D /* BlenderDNA.cpp in Sources */,
+				7F79243D1AB43E20005A8E5D /* BlenderLoader.cpp in Sources */,
+				7F79243E1AB43E20005A8E5D /* BlenderModifier.cpp in Sources */,
+				7F79243F1AB43E20005A8E5D /* BlenderScene.cpp in Sources */,
+				7F7924401AB43E20005A8E5D /* BlenderTessellator.cpp in Sources */,
+				7F7924411AB43E20005A8E5D /* COBLoader.cpp in Sources */,
+				7F7924421AB43E20005A8E5D /* CSMLoader.cpp in Sources */,
+				7F7924431AB43E20005A8E5D /* CalcTangentsProcess.cpp in Sources */,
+				7F7924441AB43E20005A8E5D /* ColladaExporter.cpp in Sources */,
+				7F7924451AB43E20005A8E5D /* ColladaLoader.cpp in Sources */,
+				7F7924461AB43E20005A8E5D /* ColladaParser.cpp in Sources */,
+				7F7924471AB43E20005A8E5D /* ComputeUVMappingProcess.cpp in Sources */,
+				7F7924481AB43E20005A8E5D /* ConvertToLHProcess.cpp in Sources */,
+				7F7924491AB43E20005A8E5D /* DXFLoader.cpp in Sources */,
+				7F79244A1AB43E20005A8E5D /* DeboneProcess.cpp in Sources */,
+				7F79244B1AB43E20005A8E5D /* DefaultIOStream.cpp in Sources */,
+				7F79244C1AB43E20005A8E5D /* DefaultIOSystem.cpp in Sources */,
+				7F7A93A81B65D0110094C4DA /* DDLNode.cpp in Sources */,
+				7F79244D1AB43E20005A8E5D /* DefaultLogger.cpp in Sources */,
+				7F79244E1AB43E20005A8E5D /* Exporter.cpp in Sources */,
+				7F79244F1AB43E20005A8E5D /* FBXAnimation.cpp in Sources */,
+				7F7924501AB43E20005A8E5D /* FBXBinaryTokenizer.cpp in Sources */,
+				7F7924511AB43E20005A8E5D /* FBXConverter.cpp in Sources */,
+				7F7924521AB43E20005A8E5D /* FBXDeformer.cpp in Sources */,
+				7F7924531AB43E20005A8E5D /* FBXDocument.cpp in Sources */,
+				7F7924541AB43E20005A8E5D /* FBXDocumentUtil.cpp in Sources */,
+				7F7924551AB43E20005A8E5D /* FBXImporter.cpp in Sources */,
+				7F7924561AB43E20005A8E5D /* FBXMaterial.cpp in Sources */,
+				7F7924571AB43E20005A8E5D /* FBXMeshGeometry.cpp in Sources */,
+				7F7924581AB43E20005A8E5D /* FBXModel.cpp in Sources */,
+				7F7924591AB43E20005A8E5D /* FBXNodeAttribute.cpp in Sources */,
+				7F79245A1AB43E20005A8E5D /* FBXParser.cpp in Sources */,
+				7F79245B1AB43E20005A8E5D /* FBXProperties.cpp in Sources */,
+				7F79245C1AB43E20005A8E5D /* FBXTokenizer.cpp in Sources */,
+				7F79245D1AB43E20005A8E5D /* FBXUtil.cpp in Sources */,
+				7F7A93A91B65D0110094C4DA /* OpenDDLParser.cpp in Sources */,
+				7F79245E1AB43E20005A8E5D /* FindDegenerates.cpp in Sources */,
+				7F79245F1AB43E20005A8E5D /* FindInstancesProcess.cpp in Sources */,
+				7F7924601AB43E20005A8E5D /* FindInvalidDataProcess.cpp in Sources */,
+				7F7924611AB43E20005A8E5D /* FixNormalsStep.cpp in Sources */,
+				7F7924621AB43E20005A8E5D /* GenFaceNormalsProcess.cpp in Sources */,
+				7F7924631AB43E20005A8E5D /* GenVertexNormalsProcess.cpp in Sources */,
+				7F7924641AB43E20005A8E5D /* HMPLoader.cpp in Sources */,
+				7F7924651AB43E20005A8E5D /* IFCBoolean.cpp in Sources */,
+				7F7924661AB43E20005A8E5D /* IFCCurve.cpp in Sources */,
+				7F7924671AB43E20005A8E5D /* IFCGeometry.cpp in Sources */,
+				7F7924681AB43E20005A8E5D /* IFCLoader.cpp in Sources */,
+				7F7924691AB43E20005A8E5D /* IFCMaterial.cpp in Sources */,
+				7F79246A1AB43E20005A8E5D /* IFCOpenings.cpp in Sources */,
+				7F79246B1AB43E20005A8E5D /* IFCProfile.cpp in Sources */,
+				7FBEA0121B65B11800D2115E /* Version.cpp in Sources */,
+				7F79246C1AB43E20005A8E5D /* IFCReaderGen.cpp in Sources */,
+				7F79246D1AB43E20005A8E5D /* IFCUtil.cpp in Sources */,
+				7F79246E1AB43E20005A8E5D /* IRRLoader.cpp in Sources */,
+				7F79246F1AB43E20005A8E5D /* IRRMeshLoader.cpp in Sources */,
+				7F7924701AB43E20005A8E5D /* IRRShared.cpp in Sources */,
+				7F7924711AB43E20005A8E5D /* Importer.cpp in Sources */,
+				7F7924721AB43E20005A8E5D /* ImporterRegistry.cpp in Sources */,
+				7F7924731AB43E20005A8E5D /* ImproveCacheLocality.cpp in Sources */,
+				7F7924741AB43E20005A8E5D /* JoinVerticesProcess.cpp in Sources */,
+				7F7924751AB43E20005A8E5D /* LWOAnimation.cpp in Sources */,
+				7F7924761AB43E20005A8E5D /* LWOBLoader.cpp in Sources */,
+				7F7924771AB43E20005A8E5D /* LWOLoader.cpp in Sources */,
+				7F7924781AB43E20005A8E5D /* LWOMaterial.cpp in Sources */,
+				7F7924791AB43E20005A8E5D /* LWSLoader.cpp in Sources */,
+				7F79247A1AB43E20005A8E5D /* LimitBoneWeightsProcess.cpp in Sources */,
+				7F79247B1AB43E20005A8E5D /* MD2Loader.cpp in Sources */,
+				7F79247C1AB43E20005A8E5D /* MD3Loader.cpp in Sources */,
+				7F79247D1AB43E20005A8E5D /* MD5Loader.cpp in Sources */,
+				7F79247E1AB43E20005A8E5D /* MD5Parser.cpp in Sources */,
+				7F79247F1AB43E20005A8E5D /* MDCLoader.cpp in Sources */,
+				7F7924801AB43E20005A8E5D /* MDLLoader.cpp in Sources */,
+				7F7924811AB43E20005A8E5D /* MDLMaterialLoader.cpp in Sources */,
+				7F7924821AB43E20005A8E5D /* MS3DLoader.cpp in Sources */,
+				7FBE9FEB1B65AC1200D2115E /* OpenGEXImporter.cpp in Sources */,
+				7F7924831AB43E20005A8E5D /* MakeVerboseFormat.cpp in Sources */,
+				7F7924841AB43E20005A8E5D /* MaterialSystem.cpp in Sources */,
+				7F7924851AB43E20005A8E5D /* NDOLoader.cpp in Sources */,
+				7F7924861AB43E20005A8E5D /* NFFLoader.cpp in Sources */,
+				7F7924871AB43E20005A8E5D /* OFFLoader.cpp in Sources */,
+				7F7924881AB43E20005A8E5D /* ObjExporter.cpp in Sources */,
+				7F7924891AB43E20005A8E5D /* ObjFileImporter.cpp in Sources */,
+				7F79248A1AB43E20005A8E5D /* ObjFileMtlImporter.cpp in Sources */,
+				7F79248B1AB43E20005A8E5D /* ObjFileParser.cpp in Sources */,
+				7F79248C1AB43E20005A8E5D /* OgreBinarySerializer.cpp in Sources */,
+				7F79248D1AB43E20005A8E5D /* OgreImporter.cpp in Sources */,
+				7F79248E1AB43E20005A8E5D /* OgreMaterial.cpp in Sources */,
+				7F79248F1AB43E20005A8E5D /* OgreStructs.cpp in Sources */,
+				7F7924901AB43E20005A8E5D /* OgreXmlSerializer.cpp in Sources */,
+				7F7924911AB43E20005A8E5D /* OptimizeGraph.cpp in Sources */,
+				7F7924921AB43E20005A8E5D /* OptimizeMeshes.cpp in Sources */,
+				7F7924931AB43E20005A8E5D /* PlyExporter.cpp in Sources */,
+				7F7924941AB43E20005A8E5D /* PlyLoader.cpp in Sources */,
+				7F7924951AB43E20005A8E5D /* PlyParser.cpp in Sources */,
+				7F7924961AB43E20005A8E5D /* PostStepRegistry.cpp in Sources */,
+				7F7924971AB43E20005A8E5D /* PretransformVertices.cpp in Sources */,
+				7F7924981AB43E20005A8E5D /* ProcessHelper.cpp in Sources */,
+				7F7A93AA1B65D0110094C4DA /* Value.cpp in Sources */,
+				7F7924991AB43E20005A8E5D /* Q3BSPFileImporter.cpp in Sources */,
+				7F79249A1AB43E20005A8E5D /* Q3BSPFileParser.cpp in Sources */,
+				7F79249B1AB43E20005A8E5D /* Q3BSPZipArchive.cpp in Sources */,
+				7F79249C1AB43E20005A8E5D /* Q3DLoader.cpp in Sources */,
+				7F79249D1AB43E20005A8E5D /* RawLoader.cpp in Sources */,
+				7F79249E1AB43E20005A8E5D /* RemoveComments.cpp in Sources */,
+				7F79249F1AB43E20005A8E5D /* RemoveRedundantMaterials.cpp in Sources */,
+				7F7924A01AB43E20005A8E5D /* RemoveVCProcess.cpp in Sources */,
+				7F7924A11AB43E20005A8E5D /* SGSpatialSort.cpp in Sources */,
+				7F7924A21AB43E20005A8E5D /* SMDLoader.cpp in Sources */,
+				7F7924A31AB43E20005A8E5D /* STEPFileEncoding.cpp in Sources */,
+				7F7924A41AB43E20005A8E5D /* STEPFileReader.cpp in Sources */,
+				7F7924A51AB43E20005A8E5D /* STLExporter.cpp in Sources */,
+				7FBE9FEA1B65AC1200D2115E /* OpenGEXExporter.cpp in Sources */,
+				7F7924A61AB43E20005A8E5D /* STLLoader.cpp in Sources */,
+				7F7924A71AB43E20005A8E5D /* SceneCombiner.cpp in Sources */,
+				7F7924A81AB43E20005A8E5D /* ScenePreprocessor.cpp in Sources */,
+				7F7924A91AB43E20005A8E5D /* SkeletonMeshBuilder.cpp in Sources */,
+				7F7924AA1AB43E20005A8E5D /* SortByPTypeProcess.cpp in Sources */,
+				7F7924AB1AB43E20005A8E5D /* SpatialSort.cpp in Sources */,
+				7F7924AC1AB43E20005A8E5D /* SplitByBoneCountProcess.cpp in Sources */,
+				7F7924AD1AB43E20005A8E5D /* SplitLargeMeshes.cpp in Sources */,
+				7F7924AE1AB43E20005A8E5D /* StandardShapes.cpp in Sources */,
+				7F7924AF1AB43E20005A8E5D /* Subdivision.cpp in Sources */,
+				7F7924B01AB43E20005A8E5D /* TargetAnimation.cpp in Sources */,
+				7F7924B11AB43E20005A8E5D /* TerragenLoader.cpp in Sources */,
+				7F7924B21AB43E20005A8E5D /* TextureTransform.cpp in Sources */,
+				7F7924B31AB43E20005A8E5D /* TriangulateProcess.cpp in Sources */,
+				7F7924B41AB43E20005A8E5D /* UnrealLoader.cpp in Sources */,
+				7F7924B51AB43E20005A8E5D /* ValidateDataStructure.cpp in Sources */,
+				7F7924B61AB43E20005A8E5D /* VertexTriangleAdjacency.cpp in Sources */,
+				7F7924B71AB43E20005A8E5D /* XFileExporter.cpp in Sources */,
+				7F7924B81AB43E20005A8E5D /* XFileImporter.cpp in Sources */,
+				7F7924B91AB43E20005A8E5D /* XFileParser.cpp in Sources */,
+				7F7924BA1AB43E20005A8E5D /* XGLLoader.cpp in Sources */,
+				7F7924BB1AB43E20005A8E5D /* ConvertUTF.c in Sources */,
+				7F7924BC1AB43E20005A8E5D /* clipper.cpp in Sources */,
+				7F7924BD1AB43E20005A8E5D /* irrXML.cpp in Sources */,
+				7F7924BE1AB43E20005A8E5D /* shapes.cc in Sources */,
+				7F7924BF1AB43E20005A8E5D /* advancing_front.cc in Sources */,
+				7F7924C01AB43E20005A8E5D /* cdt.cc in Sources */,
+				7F7924C11AB43E20005A8E5D /* sweep.cc in Sources */,
+				7F7924C21AB43E20005A8E5D /* sweep_context.cc in Sources */,
+				7F7924C31AB43E20005A8E5D /* ioapi.c in Sources */,
+				7F7924C41AB43E20005A8E5D /* unzip.c in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		137567A2412C45B8A269E344 /* RelWithDebInfo */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_PREPROCESSOR_DEFINITIONS = NDEBUG;
+				MACH_O_TYPE = staticlib;
+				SUPPORTED_PLATFORMS = "iphonesimulator iphoneos macosx";
+			};
+			name = RelWithDebInfo;
+		};
+		7F7922921AB43AC3005A8E5D /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "c++98";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = NO;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = NO;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COMBINE_HIDPI_IMAGES = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				DYLIB_COMPATIBILITY_VERSION = 3.0.0;
+				DYLIB_CURRENT_VERSION = 3.1.1;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_GENERATE_DEBUGGING_SYMBOLS = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					assimp_EXPORTS,
+					ASSIMP_BUILD_BOOST_WORKAROUND,
+					ASSIMP_BUILD_NO_OWN_ZLIB,
+					ASSIMP_BUILD_NO_C4D_IMPORTER,
+					ASSIMP_BUILD_DLL_EXPORT,
+					"$(inherited)",
+				);
+				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = NO;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SKIP_INSTALL = YES;
+				USER_HEADER_SEARCH_PATHS = "code code/BoostWorkaround contrib/openddlparser/include include $(inherited)";
+			};
+			name = Debug;
+		};
+		7F7922931AB43AC3005A8E5D /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "c++98";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = NO;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = NO;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COMBINE_HIDPI_IMAGES = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				DYLIB_COMPATIBILITY_VERSION = 3.0.0;
+				DYLIB_CURRENT_VERSION = 3.1.1;
+				ENABLE_NS_ASSERTIONS = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = fast;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					assimp_EXPORTS,
+					ASSIMP_BUILD_BOOST_WORKAROUND,
+					ASSIMP_BUILD_NO_OWN_ZLIB,
+					ASSIMP_BUILD_NO_C4D_IMPORTER,
+					ASSIMP_BUILD_DLL_EXPORT,
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = NO;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SKIP_INSTALL = YES;
+				USER_HEADER_SEARCH_PATHS = "code code/BoostWorkaround contrib/openddlparser/include include $(inherited)";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		7F7922941AB43AC3005A8E5D /* MinSizeRel */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "c++98";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = NO;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = NO;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COMBINE_HIDPI_IMAGES = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				DYLIB_COMPATIBILITY_VERSION = 3.0.0;
+				DYLIB_CURRENT_VERSION = 3.1.1;
+				ENABLE_NS_ASSERTIONS = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					assimp_EXPORTS,
+					ASSIMP_BUILD_BOOST_WORKAROUND,
+					ASSIMP_BUILD_NO_OWN_ZLIB,
+					ASSIMP_BUILD_NO_C4D_IMPORTER,
+					ASSIMP_BUILD_DLL_EXPORT,
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = NO;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SKIP_INSTALL = YES;
+				USER_HEADER_SEARCH_PATHS = "code code/BoostWorkaround contrib/openddlparser/include include $(inherited)";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = MinSizeRel;
+		};
+		7F7922951AB43AC3005A8E5D /* RelWithDebInfo */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "c++98";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = NO;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = NO;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COMBINE_HIDPI_IMAGES = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				DYLIB_COMPATIBILITY_VERSION = 3.0.0;
+				DYLIB_CURRENT_VERSION = 3.1.1;
+				ENABLE_NS_ASSERTIONS = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_GENERATE_DEBUGGING_SYMBOLS = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					assimp_EXPORTS,
+					ASSIMP_BUILD_BOOST_WORKAROUND,
+					ASSIMP_BUILD_NO_OWN_ZLIB,
+					ASSIMP_BUILD_NO_C4D_IMPORTER,
+					ASSIMP_BUILD_DLL_EXPORT,
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = NO;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SKIP_INSTALL = YES;
+				USER_HEADER_SEARCH_PATHS = "code code/BoostWorkaround contrib/openddlparser/include include $(inherited)";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = RelWithDebInfo;
+		};
+		9604718722A94CBB9F87A9D8 /* MinSizeRel */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_PREPROCESSOR_DEFINITIONS = NDEBUG;
+				MACH_O_TYPE = staticlib;
+				SUPPORTED_PLATFORMS = "iphonesimulator iphoneos macosx";
+			};
+			name = MinSizeRel;
+		};
+		C58F2FA1D18E452FBFD3B286 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ENABLE_TESTABILITY = YES;
+				GCC_PREPROCESSOR_DEFINITIONS = "DEBUG=1";
+				MACH_O_TYPE = staticlib;
+				ONLY_ACTIVE_ARCH = YES;
+				SUPPORTED_PLATFORMS = "iphonesimulator iphoneos macosx";
+			};
+			name = Debug;
+		};
+		DB0088F8DB7C490CBA3CCB90 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_PREPROCESSOR_DEFINITIONS = NDEBUG;
+				MACH_O_TYPE = staticlib;
+				SUPPORTED_PLATFORMS = "iphonesimulator iphoneos macosx";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		0C36C32B633D49CB92166176 /* Build configuration list for PBXProject "Assimp" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				C58F2FA1D18E452FBFD3B286 /* Debug */,
+				DB0088F8DB7C490CBA3CCB90 /* Release */,
+				9604718722A94CBB9F87A9D8 /* MinSizeRel */,
+				137567A2412C45B8A269E344 /* RelWithDebInfo */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Debug;
+		};
+		7F7922911AB43AC3005A8E5D /* Build configuration list for PBXNativeTarget "assimp" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				7F7922921AB43AC3005A8E5D /* Debug */,
+				7F7922931AB43AC3005A8E5D /* Release */,
+				7F7922941AB43AC3005A8E5D /* MinSizeRel */,
+				7F7922951AB43AC3005A8E5D /* RelWithDebInfo */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Debug;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 9DE203BC835F4C81BCDF25CF /* Project object */;
+}

workspaces/xcode6/Assimp.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:Assimp.xcodeproj">
+   </FileRef>
+</Workspace>

workspaces/xcode6/Assimp.xcodeproj/xcshareddata/xcschemes/assimp.xcscheme

@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0700"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "7F79227F1AB43AC3005A8E5D"
+               BuildableName = "libassimp.a"
+               BlueprintName = "assimp"
+               ReferencedContainer = "container:workspaces/xcode6/Assimp.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <Testables>
+      </Testables>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "7F79227F1AB43AC3005A8E5D"
+            BuildableName = "libassimp.a"
+            BlueprintName = "assimp"
+            ReferencedContainer = "container:workspaces/xcode6/Assimp.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "7F79227F1AB43AC3005A8E5D"
+            BuildableName = "libassimp.a"
+            BlueprintName = "assimp"
+            ReferencedContainer = "container:workspaces/xcode6/Assimp.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>