From 3cf20b605dc553d0d69bacb1f71f29e14ad85fc6 Mon Sep 17 00:00:00 2001
From: aramis_acg <aramis_acg@67173fc5-114c-0410-ac8e-9d2fd5bffc1f>
Date: Fri, 21 May 2010 22:39:31 +0000
Subject: [PATCH] blender loader now loads material assignments. blender loader
 no longer produces randomized output in some scenarious. nice side effect of
 less asthetic diversity: less segfaults. assimpview is no longer topmost.

git-svn-id: https://assimp.svn.sourceforge.net/svnroot/assimp/trunk@732 67173fc5-114c-0410-ac8e-9d2fd5bffc1f
---
 code/BlenderDNA.h                       |  55 +++-
 code/BlenderDNA.inl                     | 198 +++++++++------
 code/BlenderLoader.cpp                  | 321 +++++++++++++++++++-----
 code/BlenderLoader.h                    |   9 +-
 code/BlenderScene.cpp                   | 177 ++++++-------
 code/BlenderScene.h                     |  18 +-
 scripts/BlenderImporter/genblenddna.py  |  42 ++--
 test/models/BLEND/4Cubes4Mats_248.blend | Bin 0 -> 136684 bytes
 tools/assimp_view/assimp_view.rc        |   2 +-
 9 files changed, 545 insertions(+), 277 deletions(-)
 create mode 100644 test/models/BLEND/4Cubes4Mats_248.blend

diff --git a/code/BlenderDNA.h b/code/BlenderDNA.h
index 174291230..8796fb288 100644
--- a/code/BlenderDNA.h
+++ b/code/BlenderDNA.h
@@ -111,6 +111,27 @@ struct Pointer
 	uint64_t val;
 };
 
+// -------------------------------------------------------------------------------
+/** Dummy derivate of std::vector to be able to use it in templates simultaenously
+ *  with boost::shared_ptr, which takes only one template argument 
+ *  while std::vector takes three. Also we need to provide some special member
+ *  functions of shared_ptr */
+// -------------------------------------------------------------------------------
+template <typename T>
+class vector : public std::vector<T>
+{
+public:
+	using std::vector<T>::resize;
+	using std::vector<T>::empty;
+
+	void reset() {
+		resize(0);
+	}
+
+	operator bool () const {
+		return !empty();
+	}
+};
 
 // -------------------------------------------------------------------------------
 /** Mixed flags for use in #Field */
@@ -181,7 +202,7 @@ public:
 
 	// publicly accessible members
 	std::string name;
-	std::vector< Field > fields;
+	vector< Field > fields;
 	std::map<std::string, size_t> indices;
 
 	size_t size;
@@ -255,6 +276,11 @@ private:
 	void ResolvePointer(TOUT<T>& out, const Pointer & ptrval, 
 		const FileDatabase& db, const Field& f) const;
 
+	// --------------------------------------------------------
+	template <template <typename> class TOUT, typename T>
+	void ResolvePointer(vector< TOUT<T> >& out, const Pointer & ptrval, 
+		const FileDatabase& db, const Field& f) const;
+
 	// --------------------------------------------------------
 	inline const FileBlockHead* LocateFileBlockForAddress(
 		const Pointer & ptrval,
@@ -263,13 +289,15 @@ private:
 private:
 
 	// ------------------------------------------------------------------------------
-	template <typename T> void _allocate(boost::shared_ptr<T>& out, size_t& s) const {
+	template <typename T> T* _allocate(boost::shared_ptr<T>& out, size_t& s) const {
 		out = boost::shared_ptr<T>(new T());
 		s = 1;
+		return out.get();
 	}
 
-	template <typename T> void _allocate(boost::shared_array<T>& out, size_t& s) const {
-		out = boost::shared_array<T>(new T[s]);
+	template <typename T> T* _allocate(vector<T>& out, size_t& s) const {
+		out.resize(s);
+		return s ? &out.front() : NULL;
 	}
 
 	// --------------------------------------------------------
@@ -346,7 +374,7 @@ public:
 	typedef boost::shared_ptr<ElemBase> (Structure::*ConvertProcPtr) (const FileDatabase& ) const;
 	
 	std::map<std::string, ConvertProcPtr> converters;
-	std::vector<Structure > structures;
+	vector<Structure > structures;
 	std::map<std::string, size_t> indices;
 
 public:
@@ -585,19 +613,20 @@ public:
 
 private:
 
-	mutable std::vector<StructureCache> caches;
+	mutable vector<StructureCache> caches;
 	const FileDatabase& db;
 };
 
 // -------------------------------------------------------------------------------
-template <> class ObjectCache<boost::shared_array> 
+// -------------------------------------------------------------------------------
+template <> class ObjectCache<Blender::vector> 
 {
 public:
 
 	ObjectCache(const FileDatabase&) {}
 
-	template <typename T> void get(const Structure&, boost::shared_array<T>&t, const Pointer&) {}
-	template <typename T> void set(const Structure&, const boost::shared_array<T>&, const Pointer&) {}
+	template <typename T> void get(const Structure&, vector<T>&t, const Pointer&) {}
+	template <typename T> void set(const Structure&, const vector<T>&, const Pointer&) {}
 };
 
 #ifdef _MSC_VER
@@ -629,7 +658,7 @@ public:
 
 	DNA dna;
 	boost::shared_ptr< StreamReaderAny > reader;
-	std::vector< FileBlockHead > entries;
+	vector< FileBlockHead > entries;
 
 public:
 
@@ -637,7 +666,7 @@ public:
 		return _stats;
 	}
 
-	// For all our templates to work on both shared_ptr's and shared_array's
+	// For all our templates to work on both shared_ptr's and vector's
 	// using the same code, a dummy cache for arrays is provided. Actually,
 	// arrays of objects are never cached because we can't easily 
 	// ensure their proper destruction.
@@ -647,7 +676,7 @@ public:
 	}
 
 	template <typename T>
-	ObjectCache<boost::shared_array>& cache(boost::shared_array<T>& in) const {
+	ObjectCache<vector>& cache(vector<T>& in) const {
 		return _cacheArrays;
 	}
 
@@ -658,7 +687,7 @@ private:
 	mutable Statistics _stats;
 #endif
 
-	mutable ObjectCache<boost::shared_array> _cacheArrays;
+	mutable ObjectCache<vector> _cacheArrays;
 	mutable ObjectCache<boost::shared_ptr> _cache;
 
 	mutable size_t next_cache_idx;
diff --git a/code/BlenderDNA.inl b/code/BlenderDNA.inl
index 3188b6382..9adfc913e 100644
--- a/code/BlenderDNA.inl
+++ b/code/BlenderDNA.inl
@@ -242,48 +242,80 @@ template <template <typename> class TOUT, typename T>
 void Structure :: ResolvePointer(TOUT<T>& out, const Pointer & ptrval, const FileDatabase& db, const Field& f) const 
 {
 	out.reset();
-	if (ptrval.val) { 
-		const Structure& s = db.dna[f.type];
-
-		// find the file block the pointer is pointing to
-		const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db);
-
-		// also determine the target type from the block header
-		// and check if it matches the type which we expect.
-		const Structure& ss = db.dna[block->dna_index];
-		if (ss != s) {
-			throw Error((Formatter::format(),"Expected target to be of type `",s.name,
-				"` but seemingly it is a `",ss.name,"` instead"
-			));
-		}
-
-		// try to retrieve the object from the cache
-		db.cache(out).get(s,out,ptrval); 
-		if (out) {
-			return;
-		}
-
-		// seek to this location, but save the previous stream pointer.
-		const StreamReaderAny::pos pold = db.reader->GetCurrentPos();
-		db.reader->SetCurrentPos(block->start+ static_cast<size_t>((ptrval.val - block->address.val) ));
-		// FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems.
-		// I really ought to improve StreamReader to work with 64 bit indices exclusively.
-
-		// continue conversion after allocating the required storage
-		size_t num = block->size / ss.size; 
-		_allocate(out,num);
-
-		// cache the object before we convert it to avoid
-		// cyclic recursion.
-		db.cache(out).set(s,out,ptrval); 
-
-		T* o = out.get();
-		for (size_t i = 0; i < num; ++i,++o) {
-			s.Convert(*o,db);
-		}
-
-		db.reader->SetCurrentPos(pold);
+	if (!ptrval.val) { 
+		return;
 	}
+	const Structure& s = db.dna[f.type];
+	// find the file block the pointer is pointing to
+	const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db);
+
+	// also determine the target type from the block header
+	// and check if it matches the type which we expect.
+	const Structure& ss = db.dna[block->dna_index];
+	if (ss != s) {
+		throw Error((Formatter::format(),"Expected target to be of type `",s.name,
+			"` but seemingly it is a `",ss.name,"` instead"
+			));
+	}
+
+	// try to retrieve the object from the cache
+	db.cache(out).get(s,out,ptrval); 
+	if (out) {
+		return;
+	}
+
+	// seek to this location, but save the previous stream pointer.
+	const StreamReaderAny::pos pold = db.reader->GetCurrentPos();
+	db.reader->SetCurrentPos(block->start+ static_cast<size_t>((ptrval.val - block->address.val) ));
+	// FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems.
+	// I really ought to improve StreamReader to work with 64 bit indices exclusively.
+
+	// continue conversion after allocating the required storage
+	size_t num = block->size / ss.size; 
+	T* o = _allocate(out,num);
+
+	// cache the object before we convert it to avoid cyclic recursion.
+	db.cache(out).set(s,out,ptrval); 
+
+	for (size_t i = 0; i < num; ++i,++o) {
+		s.Convert(*o,db);
+	}
+
+	db.reader->SetCurrentPos(pold);
+}
+
+//--------------------------------------------------------------------------------
+template <template <typename> class TOUT, typename T>
+void Structure :: ResolvePointer(vector< TOUT<T> >& out, const Pointer & ptrval, const FileDatabase& db, const Field& f) const 
+{
+	// This is a function overload, not a template specialization. According to
+	// the partial ordering rules, it should be selected by the compiler
+	// for array-of-pointer inputs, i.e. Object::mats.
+
+	out.reset();
+	if (!ptrval.val) { 
+		return;
+	}
+
+	// find the file block the pointer is pointing to
+	const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db);
+	const size_t num = block->size / (db.i64bit?8:4); 
+
+	// keep the old stream position
+	const StreamReaderAny::pos pold = db.reader->GetCurrentPos();
+	db.reader->SetCurrentPos(block->start+ static_cast<size_t>((ptrval.val - block->address.val) ));
+
+	// allocate raw storage for the array
+	out.resize(num);
+	for (size_t i = 0; i< num; ++i) {
+		Pointer val;
+		Convert(val,db);
+
+		// and resolve the pointees
+		ResolvePointer(out[i],val,db,f); 
+	}
+
+	db.reader->SetCurrentPos(pold);
 }
 
 //--------------------------------------------------------------------------------
@@ -297,47 +329,49 @@ template <> void Structure :: ResolvePointer<boost::shared_ptr,ElemBase>(boost::
 	// Less secure than in the `strongly-typed` case.
 
 	out.reset();
-	if (ptrval.val) { 
-		// find the file block the pointer is pointing to
-		const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db);
-
-		// determine the target type from the block header
-		const Structure& s = db.dna[block->dna_index];
-
-		// try to retrieve the object from the cache
-		db.cache(out).get(s,out,ptrval); 
-		if (out) {
-			return;
-		}
-
-		// seek to this location, but save the previous stream pointer.
-		const StreamReaderAny::pos pold = db.reader->GetCurrentPos();
-		db.reader->SetCurrentPos(block->start+ static_cast<size_t>((ptrval.val - block->address.val) ));
-		// FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems.
-		// I really ought to improve StreamReader to work with 64 bit indices exclusively.
-
-		// continue conversion after allocating the required storage
-		out = db.dna.ConvertBlobToStructure(s,db);
-		db.reader->SetCurrentPos(pold);
-		if (!out) {
-			// this might happen if DNA::RegisterConverters hasn't been called so far
-			// or if the target type is not contained in `our` DNA.
-			out.reset();
-			DefaultLogger::get()->warn((Formatter::format(),
-				"Failed to find a converter for the `",s.name,"` structure"
-			));
-			return;
-		}
-
-		// store a pointer to the name string of the actual type
-		// in the object itself. This allows the conversion code
-		// to perform additional type checking.
-		out->dna_type = s.name.c_str();
-
-		// cache the object now that construction is complete
-		// FIXME we need to do this in ConvertBlobToStructure
-		db.cache(out).set(s,out,ptrval);
+	if (!ptrval.val) { 
+		return;
 	}
+
+	// find the file block the pointer is pointing to
+	const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db);
+
+	// determine the target type from the block header
+	const Structure& s = db.dna[block->dna_index];
+
+	// try to retrieve the object from the cache
+	db.cache(out).get(s,out,ptrval); 
+	if (out) {
+		return;
+	}
+
+	// seek to this location, but save the previous stream pointer.
+	const StreamReaderAny::pos pold = db.reader->GetCurrentPos();
+	db.reader->SetCurrentPos(block->start+ static_cast<size_t>((ptrval.val - block->address.val) ));
+	// FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems.
+	// I really ought to improve StreamReader to work with 64 bit indices exclusively.
+
+	// continue conversion after allocating the required storage
+	out = db.dna.ConvertBlobToStructure(s,db);
+	db.reader->SetCurrentPos(pold);
+	if (!out) {
+		// this might happen if DNA::RegisterConverters hasn't been called so far
+		// or if the target type is not contained in `our` DNA.
+		out.reset();
+		DefaultLogger::get()->warn((Formatter::format(),
+			"Failed to find a converter for the `",s.name,"` structure"
+			));
+		return;
+	}
+
+	// store a pointer to the name string of the actual type
+	// in the object itself. This allows the conversion code
+	// to perform additional type checking.
+	out->dna_type = s.name.c_str();
+
+	// cache the object now that construction is complete
+	// FIXME we need to do this in ConvertBlobToStructure
+	db.cache(out).set(s,out,ptrval);
 }
 
 //--------------------------------------------------------------------------------
@@ -352,7 +386,7 @@ const FileBlockHead* Structure :: LocateFileBlockForAddress(const Pointer & ptrv
 	// which are only used for structures starting with an ID.
 	// We don't need to make this distinction, our algorithm
 	// works regardless where the data is stored.
-	std::vector<FileBlockHead>::const_iterator it = std::lower_bound(db.entries.begin(),db.entries.end(),ptrval);
+	vector<FileBlockHead>::const_iterator it = std::lower_bound(db.entries.begin(),db.entries.end(),ptrval);
 	if (it == db.entries.end()) {
 		// this is crucial, pointers may not be invalid.
 		// this is either a corrupted file or an attempted attack.
diff --git a/code/BlenderLoader.cpp b/code/BlenderLoader.cpp
index d0e35bf5b..ebd24736a 100644
--- a/code/BlenderLoader.cpp
+++ b/code/BlenderLoader.cpp
@@ -58,7 +58,7 @@ using namespace Assimp;
 using namespace Assimp::Blender;
 using namespace Assimp::Formatter;
 
-#define for_each BOOST_FOREACH
+#define for_each(x,y) BOOST_FOREACH(x,y)
 
 static const aiLoaderDesc blenderDesc = {
 	"Blender 3D Importer \nhttp://www.blender3d.org",
@@ -75,9 +75,13 @@ static const aiLoaderDesc blenderDesc = {
 namespace Assimp {
 namespace Blender {
 
-	/** Mini smart-array to avoid pulling in even more boost stuff */
+	/** Mini smart-array to avoid pulling in even more boost stuff. usable with vector and deque */
 	template <template <typename,typename> class TCLASS, typename T>
 	struct TempArray	{
+
+		TempArray() {
+		}
+
 		~TempArray () {
 			for_each(T* elem, arr) {
 				delete elem;
@@ -96,6 +100,26 @@ namespace Blender {
 			return arr;
 		}
 
+		TCLASS< T*,std::allocator<T*> >& get () {
+			return arr;
+		}
+
+		const TCLASS< T*,std::allocator<T*> >& get () const {
+			return arr;
+		}
+
+		T* operator[] (size_t idx) const {
+			return arr[idx];
+		}
+
+	private:
+		// no copy semantics
+		void operator= (const TempArray&)  {
+		}
+
+		TempArray(const TempArray& arr) {
+		}
+
 	private:
 		TCLASS< T*,std::allocator<T*> > arr;
 	};
@@ -109,6 +133,9 @@ namespace Blender {
 		TempArray <std::vector, aiCamera> cameras;
 		TempArray <std::vector, aiLight> lights;
 		TempArray <std::vector, aiMaterial> materials;
+
+		// set of all materials referenced by at least one mesh in the scene
+		std::deque< boost::shared_ptr< Material > > materials_raw;
 	};
 }
 }
@@ -304,6 +331,8 @@ void BlenderImporter::ConvertBlendFile(aiScene* out, const Scene& in)
 		root->mChildren[i]->mParent = root;
 	}
 
+	BuildMaterials(conv);
+
 	if (conv.meshes->size()) {
 		out->mMeshes = new aiMesh*[out->mNumMeshes = static_cast<unsigned int>( conv.meshes->size() )];
 		std::copy(conv.meshes->begin(),conv.meshes->end(),out->mMeshes);
@@ -332,12 +361,67 @@ void BlenderImporter::ConvertBlendFile(aiScene* out, const Scene& in)
 	// acknowledge that the scene might come out incomplete
 	// by Assimps definition of `complete`: blender scenes
 	// can consist of thousands of cameras or lights with
-	// not a single mesh in them.
+	// not a single mesh between them.
 	if (!out->mNumMeshes) {
 		out->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
 	}
 }
 
+// ------------------------------------------------------------------------------------------------
+void BlenderImporter::BuildMaterials(ConversionData& conv_data) 
+{
+	conv_data.materials->reserve(conv_data.materials_raw.size());
+
+	// add a default material if necessary
+	unsigned int index = static_cast<unsigned int>( -1 );
+	for_each( aiMesh* mesh, conv_data.meshes.get() ) {
+		if (mesh->mMaterialIndex == static_cast<unsigned int>( -1 )) {
+
+			if (index == static_cast<unsigned int>( -1 )) {
+
+				// ok, we need to add a dedicated default material for some poor material-less meshes
+				boost::shared_ptr<Material> p(new Material());
+				strcpy( p->id.name, "$AssimpDefault" );
+
+				p->r = p->g = p->b = 0.6f;
+				p->specr = p->specg = p->specb = 0.6f;
+				p->ambir = p->ambig = p->ambib = 0.0f;
+				p->emit = 0.f;
+				p->alpha = 0.f;
+
+				// XXX add more / or add default c'tor to Material
+
+				index = static_cast<unsigned int>( conv_data.materials_raw.size() );
+				conv_data.materials_raw.push_back(p);
+
+				LogInfo("Adding default material ...");
+			}
+			mesh->mMaterialIndex = index;
+		}
+	}
+
+	for_each(boost::shared_ptr<Material> mat, conv_data.materials_raw) {
+	
+		MaterialHelper* mout = new MaterialHelper();
+		conv_data.materials->push_back(mout);
+
+		// set material name
+		aiString name = aiString(mat->id.name);
+		mout->AddProperty(&name,AI_MATKEY_NAME);
+
+
+		// basic material colors
+		aiColor3D col(mat->r,mat->g,mat->b);
+		mout->AddProperty(&col,1,AI_MATKEY_COLOR_DIFFUSE);
+
+		col = aiColor3D(mat->specr,mat->specg,mat->specb);
+		mout->AddProperty(&col,1,AI_MATKEY_COLOR_SPECULAR);
+
+		col = aiColor3D(mat->ambir,mat->ambig,mat->ambib);
+		mout->AddProperty(&col,1,AI_MATKEY_COLOR_AMBIENT);
+	}
+}
+
 // ------------------------------------------------------------------------------------------------
 void BlenderImporter::CheckActualType(const ElemBase* dt, const char* check)
 {
@@ -357,25 +441,93 @@ void BlenderImporter::NotSupportedObjectType(const Object* obj, const char* type
 }
 
 // ------------------------------------------------------------------------------------------------
-aiMesh* BlenderImporter::ConvertMesh(const Scene& in, const Object* obj, const Mesh* mesh, ConversionData& conv_data) 
+void BlenderImporter::ConvertMesh(const Scene& in, const Object* obj, const Mesh* mesh, 
+	ConversionData& conv_data, TempArray<std::vector,aiMesh>&  temp
+	) 
 {
+	typedef std::pair<const int,size_t> MyPair;
 	if (!mesh->totface || !mesh->totvert) {
-		return NULL;
+		return;
 	}
 
-	ScopeGuard<aiMesh> out(new aiMesh());
+	// some sanity checks
+	if (mesh->totface > mesh->mface.size() ){
+		ThrowException("Number of faces is larger than the corresponding array");
+	}
 
-	aiVector3D* vo = out->mVertices = new aiVector3D[mesh->totface*4];
-	aiVector3D* vn = out->mNormals  = new aiVector3D[mesh->totface*4];
+	if (mesh->totvert > mesh->mvert.size()) {
+		ThrowException("Number of vertices is larger than the corresponding array");
+	}
 
-	out->mNumFaces = mesh->totface;
-	out->mFaces = new aiFace[out->mNumFaces]();
-
-	for (unsigned int i = 0; i < out->mNumFaces; ++i) {
-		aiFace& f = out->mFaces[i];
+	// collect per-submesh numbers
+	std::map<int,size_t> per_mat;
+	for (int i = 0; i < mesh->totface; ++i) {
 
 		const MFace& mf = mesh->mface[i];
+		per_mat[ mf.mat_nr ]++;
+	}
+
+	// ... and allocate the corresponding meshes
+	const size_t old = temp->size();
+	temp->reserve(temp->size() + per_mat.size());
+
+	std::map<size_t,size_t> mat_num_to_mesh_idx;
+	for_each(MyPair& it, per_mat) {
+
+		mat_num_to_mesh_idx[it.first] = temp->size();
+		temp->push_back(new aiMesh());
+
+		aiMesh* out = temp->back();
+		out->mVertices = new aiVector3D[it.second*4];
+		out->mNormals  = new aiVector3D[it.second*4];
+
+		//out->mNumFaces = 0
+		//out->mNumVertices = 0
+		out->mFaces = new aiFace[it.second]();
+
+		// all submeshes created from this mesh are named equally. this allows
+		// curious users to recover the original adjacency.
+		out->mName = aiString(mesh->id.name);
+
+		// resolve the material reference and add this material to the set of
+		// output materials. The (temporary) material index is the index 
+		// of the material entry within the list of resolved materials.
+		if (mesh->mat) {
+
+			if (it.first >= mesh->mat.size() ) {
+				ThrowException("Material index is out of range");
+			}
+
+			boost::shared_ptr<Material> mat = mesh->mat[it.first];
+			const std::deque< boost::shared_ptr<Material> >::iterator has = std::find(
+					conv_data.materials_raw.begin(),
+					conv_data.materials_raw.end(),mat
+			);
+
+			if (has != conv_data.materials_raw.end()) {
+				out->mMaterialIndex = static_cast<unsigned int>( std::distance(conv_data.materials_raw.begin(),has));
+			}
+			else {
+				out->mMaterialIndex = static_cast<unsigned int>( conv_data.materials_raw.size() );
+				conv_data.materials_raw.push_back(mat);
+			}
+		}
+		else out->mMaterialIndex = static_cast<unsigned int>( -1 );
+	}
+
+	for (int i = 0; i < mesh->totface; ++i) {
+
+		const MFace& mf = mesh->mface[i];
+
+		aiMesh* const out = temp[ mat_num_to_mesh_idx[ mf.mat_nr ] ];
+		aiFace& f = out->mFaces[out->mNumFaces++];
+
 		f.mIndices = new unsigned int[ f.mNumIndices = mf.v4?4:3 ];
+		aiVector3D* vo = out->mVertices + out->mNumVertices;
+		aiVector3D* vn = out->mNormals + out->mNumVertices;
+
+		// XXX we can't fold this easily, because we are restricted
+		// to the member names from the BLEND file (v1,v2,v3,v4) ..
 
 		if (mf.v1 >= mesh->totvert) {
 			ThrowException("Vertex index v1 out of range");
@@ -426,56 +578,97 @@ aiMesh* BlenderImporter::ConvertMesh(const Scene& in, const Object* obj, const M
 		}
 		//	if (f.mNumIndices >= 4) {
 		if (mf.v4) {
-		v = &mesh->mvert[mf.v4];
-		vo->x = v->co[0];
-		vo->y = v->co[1];
-		vo->z = v->co[2];
-		vn->x = v->no[0];
-		vn->y = v->no[1];
-		vn->z = v->no[2];
-		f.mIndices[3] = out->mNumVertices++;
-		++vo;
-		++vn;
+			v = &mesh->mvert[mf.v4];
+			vo->x = v->co[0];
+			vo->y = v->co[1];
+			vo->z = v->co[2];
+			vn->x = v->no[0];
+			vn->y = v->no[1];
+			vn->z = v->no[2];
+			f.mIndices[3] = out->mNumVertices++;
+			++vo;
+			++vn;
+
+			out->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
 		}
-	
+		else out->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
+
 		//	}
 		//	}
 		//	}
 	}
 
+	// collect texture coordinates, they're stored in a separate per-face buffer
 	if (mesh->mtface) {
-		vo = out->mTextureCoords[0] = new aiVector3D[out->mNumVertices];
+		if (mesh->totface > mesh->mtface.size()) {
+			ThrowException("Number of UV faces is larger than the corresponding UV face array (#1)");
+		}
+		for (std::vector<aiMesh*>::iterator it = temp->begin()+old; it != temp->end(); ++it) {
+			ai_assert((*it)->mNumVertices && (*it)->mNumFaces);
 
-		for (unsigned int i = 0; i < out->mNumFaces; ++i) {
-			const aiFace& f = out->mFaces[i];
+			(*it)->mTextureCoords[0] = new aiVector3D[(*it)->mNumVertices];
+			(*it)->mNumFaces = (*it)->mNumVertices = 0;
+		}
 
+		for (int i = 0; i < mesh->totface; ++i) {
 			const MTFace* v = &mesh->mtface[i];
-			for (unsigned int i = 0; i < f.mNumIndices; ++i,++vo) {
-				vo->x = v->uv[i][0];
-				vo->y = v->uv[i][1];
-			}
-		}
-	}
 
-	if (mesh->tface) {
-		vo = out->mTextureCoords[0] = new aiVector3D[out->mNumVertices];
-
-		for (unsigned int i = 0; i < out->mNumFaces; ++i) {
-			const aiFace& f = out->mFaces[i];
-
-			const TFace* v = &mesh->tface[i];
-			for (unsigned int i = 0; i < f.mNumIndices; ++i,++vo) {
-				vo->x = v->uv[i][0];
-				vo->y = v->uv[i][1];
-			}
-		}
-	}
-
-	if (mesh->mcol) {
-		aiColor4D* vo = out->mColors[0] = new aiColor4D[out->mNumVertices];
-		for (unsigned int i = 0; i <  out->mNumFaces; ++i) {
+			aiMesh* const out = temp[ mat_num_to_mesh_idx[ mesh->mface[i].mat_nr ] ];
+			const aiFace& f = out->mFaces[out->mNumFaces++];
 			
-			for (unsigned int n = 0; n < 4; ++n, ++vo) {
+			aiVector3D* vo = &out->mTextureCoords[0][out->mNumVertices];
+			for (unsigned int i = 0; i < f.mNumIndices; ++i,++vo,++out->mNumVertices) {
+				vo->x = v->uv[i][0];
+				vo->y = v->uv[i][1];
+			}
+		}
+	}
+
+	// collect texture coordinates, old-style (marked as deprecated in current blender sources)
+	if (mesh->tface) {
+		if (mesh->totface > mesh->mtface.size()) {
+			ThrowException("Number of faces is larger than the corresponding UV face array (#2)");
+		}
+		for (std::vector<aiMesh*>::iterator it = temp->begin()+old; it != temp->end(); ++it) {
+			ai_assert((*it)->mNumVertices && (*it)->mNumFaces);
+
+			(*it)->mTextureCoords[0] = new aiVector3D[(*it)->mNumVertices];
+			(*it)->mNumFaces = (*it)->mNumVertices = 0;
+		}
+
+		for (int i = 0; i < mesh->totface; ++i) {
+			const TFace* v = &mesh->tface[i];
+
+			aiMesh* const out = temp[ mat_num_to_mesh_idx[ mesh->mface[i].mat_nr ] ];
+			const aiFace& f = out->mFaces[out->mNumFaces++];
+			
+			aiVector3D* vo = &out->mTextureCoords[0][out->mNumVertices];
+			for (unsigned int i = 0; i < f.mNumIndices; ++i,++vo,++out->mNumVertices) {
+				vo->x = v->uv[i][0];
+				vo->y = v->uv[i][1];
+			}
+		}
+	}
+
+	// collect vertex colors, stored separately as well
+	if (mesh->mcol) {
+		if (mesh->totface > (mesh->mcol.size()/4)) {
+			ThrowException("Number of faces is larger than the corresponding color face array");
+		}
+		for (std::vector<aiMesh*>::iterator it = temp->begin()+old; it != temp->end(); ++it) {
+			ai_assert((*it)->mNumVertices && (*it)->mNumFaces);
+
+			(*it)->mColors[0] = new aiColor4D[(*it)->mNumVertices];
+			(*it)->mNumFaces = (*it)->mNumVertices = 0;
+		}
+
+		for (int i = 0; i < mesh->totface; ++i) {
+
+			aiMesh* const out = temp[ mat_num_to_mesh_idx[ mesh->mface[i].mat_nr ] ];
+			const aiFace& f = out->mFaces[out->mNumFaces++];
+			
+			aiColor4D* vo = &out->mColors[0][out->mNumVertices];
+			for (unsigned int n = 0; n < f.mNumIndices; ++n, ++vo,++out->mNumVertices) {
 				const MCol* col = &mesh->mcol[(i<<2)+n];
 
 				vo->r = col->r;
@@ -483,10 +676,11 @@ aiMesh* BlenderImporter::ConvertMesh(const Scene& in, const Object* obj, const M
 				vo->b = col->b;
 				vo->a = col->a;
 			}
+			for (unsigned int n = f.mNumIndices; n < 4; ++n);
 		}
 	}
 
-	return out.dismiss();
+	return;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -509,15 +703,15 @@ aiLight* BlenderImporter::ConvertLight(const Scene& in, const Object* obj, const
 aiNode* BlenderImporter::ConvertNode(const Scene& in, const Object* obj, ConversionData& conv_data) 
 {
 	std::deque<const Object*> children;
-	for(std::set<const Object*>::iterator it = conv_data.objects.begin(); it != conv_data.objects.end() ;++it) {
+	for(std::set<const Object*>::iterator it = conv_data.objects.begin(); it != conv_data.objects.end() ;) {
 		const Object* object = *it;
 		if (object->parent.get() == obj) {
 			children.push_back(object);
+
 			conv_data.objects.erase(it++);
-			if(it == conv_data.objects.end()) {
-				break;
-			}
+			continue;
 		}
+		++it;
 	}
 
 	ScopeGuard<aiNode> node(new aiNode(obj->id.name));
@@ -530,15 +724,16 @@ aiNode* BlenderImporter::ConvertNode(const Scene& in, const Object* obj, Convers
 
 			// supported object types
 		case Object :: Type_MESH: {
+			const size_t old = conv_data.meshes->size();
+
 			CheckActualType(obj->data.get(),"Mesh");
-			aiMesh* mesh = ConvertMesh(in,obj,static_cast<const Mesh*>(
-				obj->data.get()),conv_data);
+			ConvertMesh(in,obj,static_cast<const Mesh*>(obj->data.get()),conv_data,conv_data.meshes);
 
-			if (mesh) {
-				node->mMeshes = new unsigned int[node->mNumMeshes = 1u];
-				node->mMeshes[0] = conv_data.meshes->size();
-
-				conv_data.meshes->push_back(mesh);
+			if (conv_data.meshes->size() > old) {
+				node->mMeshes = new unsigned int[node->mNumMeshes = static_cast<unsigned int>(conv_data.meshes->size()-old)];
+				for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
+					node->mMeshes[i] = i + old;
+				}
 			}}
 			break;
 		case Object :: Type_LAMP: {
diff --git a/code/BlenderLoader.h b/code/BlenderLoader.h
index 93ca1728a..e662edc90 100644
--- a/code/BlenderLoader.h
+++ b/code/BlenderLoader.h
@@ -71,6 +71,7 @@ namespace Assimp	{
 	// BlenderLoader.cpp
 	namespace Blender {
 		struct ConversionData;
+		template <template <typename,typename> class TCLASS, typename T> struct TempArray;
 	}
 
 
@@ -168,10 +169,11 @@ private:
 	); 
 
 	// --------------------
-	aiMesh* ConvertMesh(const Blender::Scene& in, 
+	void ConvertMesh(const Blender::Scene& in, 
 		const Blender::Object* obj, 
 		const Blender::Mesh* mesh, 
-		Blender::ConversionData& conv_data
+		Blender::ConversionData& conv_data,
+		Blender::TempArray<std::vector,aiMesh>& temp
 	); 
 
 	// --------------------
@@ -188,6 +190,9 @@ private:
 		Blender::ConversionData& conv_data
 	); 
 
+	// --------------------
+	void BuildMaterials(Blender::ConversionData& conv_data) ;
+
 private: // static stuff, mostly logging and error reporting.
 
 	// --------------------
diff --git a/code/BlenderScene.cpp b/code/BlenderScene.cpp
index 26d161023..5599a934a 100644
--- a/code/BlenderScene.cpp
+++ b/code/BlenderScene.cpp
@@ -58,18 +58,18 @@ template <> void Structure :: Convert<Object> (
     ) const
 { 
 
-    ReadField<ErrorPolicy_Igno>(dest.id,"id",db);
-    ReadField<ErrorPolicy_Igno>((int&)dest.type,"type",db);
-    ReadFieldArray2<ErrorPolicy_Igno>(dest.obmat,"obmat",db);
-    ReadFieldArray2<ErrorPolicy_Igno>(dest.parentinv,"parentinv",db);
-    ReadFieldArray<ErrorPolicy_Igno>(dest.parsubstr,"parsubstr",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.parent,"*parent",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.track,"*track",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.proxy,"*proxy",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.proxy_from,"*proxy_from",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.proxy_group,"*proxy_group",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.dup_group,"*dup_group",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.data,"*data",db);
+    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
+    ReadField<ErrorPolicy_Fail>((int&)dest.type,"type",db);
+    ReadFieldArray2<ErrorPolicy_Warn>(dest.obmat,"obmat",db);
+    ReadFieldArray2<ErrorPolicy_Warn>(dest.parentinv,"parentinv",db);
+    ReadFieldArray<ErrorPolicy_Warn>(dest.parsubstr,"parsubstr",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.parent,"*parent",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.track,"*track",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy,"*proxy",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy_from,"*proxy_from",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy_group,"*proxy_group",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.dup_group,"*dup_group",db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.data,"*data",db);
 
 	db.reader->IncPtr(size);
 }
@@ -81,7 +81,7 @@ template <> void Structure :: Convert<Group> (
     ) const
 { 
 
-    ReadField<ErrorPolicy_Igno>(dest.id,"id",db);
+    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
     ReadField<ErrorPolicy_Igno>(dest.layer,"layer",db);
     ReadFieldPtr<ErrorPolicy_Igno>(dest.gobject,"*gobject",db);
 
@@ -110,10 +110,10 @@ template <> void Structure :: Convert<MTex> (
     ReadField<ErrorPolicy_Igno>(dest.colormodel,"colormodel",db);
     ReadField<ErrorPolicy_Igno>(dest.pmapto,"pmapto",db);
     ReadField<ErrorPolicy_Igno>(dest.pmaptoneg,"pmaptoneg",db);
-    ReadField<ErrorPolicy_Igno>(dest.r,"r",db);
-    ReadField<ErrorPolicy_Igno>(dest.g,"g",db);
-    ReadField<ErrorPolicy_Igno>(dest.b,"b",db);
-    ReadField<ErrorPolicy_Igno>(dest.k,"k",db);
+    ReadField<ErrorPolicy_Warn>(dest.r,"r",db);
+    ReadField<ErrorPolicy_Warn>(dest.g,"g",db);
+    ReadField<ErrorPolicy_Warn>(dest.b,"b",db);
+    ReadField<ErrorPolicy_Warn>(dest.k,"k",db);
     ReadField<ErrorPolicy_Igno>(dest.colspecfac,"colspecfac",db);
     ReadField<ErrorPolicy_Igno>(dest.mirrfac,"mirrfac",db);
     ReadField<ErrorPolicy_Igno>(dest.alphafac,"alphafac",db);
@@ -132,8 +132,8 @@ template <> void Structure :: Convert<TFace> (
     ) const
 { 
 
-    ReadFieldArray2<ErrorPolicy_Igno>(dest.uv,"uv",db);
-    ReadFieldArray<ErrorPolicy_Igno>(dest.col,"col",db);
+    ReadFieldArray2<ErrorPolicy_Fail>(dest.uv,"uv",db);
+    ReadFieldArray<ErrorPolicy_Fail>(dest.col,"col",db);
     ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
     ReadField<ErrorPolicy_Igno>(dest.mode,"mode",db);
     ReadField<ErrorPolicy_Igno>(dest.tile,"tile",db);
@@ -149,11 +149,11 @@ template <> void Structure :: Convert<MFace> (
     ) const
 { 
 
-    ReadField<ErrorPolicy_Igno>(dest.v1,"v1",db);
-    ReadField<ErrorPolicy_Igno>(dest.v2,"v2",db);
-    ReadField<ErrorPolicy_Igno>(dest.v3,"v3",db);
-    ReadField<ErrorPolicy_Igno>(dest.v4,"v4",db);
-    ReadField<ErrorPolicy_Igno>(dest.mat_nr,"mat_nr",db);
+    ReadField<ErrorPolicy_Fail>(dest.v1,"v1",db);
+    ReadField<ErrorPolicy_Fail>(dest.v2,"v2",db);
+    ReadField<ErrorPolicy_Fail>(dest.v3,"v3",db);
+    ReadField<ErrorPolicy_Fail>(dest.v4,"v4",db);
+    ReadField<ErrorPolicy_Fail>(dest.mat_nr,"mat_nr",db);
     ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
 
 	db.reader->IncPtr(size);
@@ -166,15 +166,15 @@ template <> void Structure :: Convert<Lamp> (
     ) const
 { 
 
-    ReadField<ErrorPolicy_Igno>(dest.id,"id",db);
-    ReadField<ErrorPolicy_Igno>((int&)dest.type,"type",db);
+    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
+    ReadField<ErrorPolicy_Fail>((int&)dest.type,"type",db);
     ReadField<ErrorPolicy_Igno>(dest.flags,"flags",db);
     ReadField<ErrorPolicy_Igno>(dest.colormodel,"colormodel",db);
     ReadField<ErrorPolicy_Igno>(dest.totex,"totex",db);
-    ReadField<ErrorPolicy_Igno>(dest.r,"r",db);
-    ReadField<ErrorPolicy_Igno>(dest.g,"g",db);
-    ReadField<ErrorPolicy_Igno>(dest.b,"b",db);
-    ReadField<ErrorPolicy_Igno>(dest.k,"k",db);
+    ReadField<ErrorPolicy_Warn>(dest.r,"r",db);
+    ReadField<ErrorPolicy_Warn>(dest.g,"g",db);
+    ReadField<ErrorPolicy_Warn>(dest.b,"b",db);
+    ReadField<ErrorPolicy_Warn>(dest.k,"k",db);
     ReadField<ErrorPolicy_Igno>(dest.energy,"energy",db);
     ReadField<ErrorPolicy_Igno>(dest.dist,"dist",db);
     ReadField<ErrorPolicy_Igno>(dest.spotsize,"spotsize",db);
@@ -194,8 +194,8 @@ template <> void Structure :: Convert<MDeformWeight> (
     ) const
 { 
 
-    ReadField<ErrorPolicy_Igno>(dest.def_nr,"def_nr",db);
-    ReadField<ErrorPolicy_Igno>(dest.weight,"weight",db);
+    ReadField<ErrorPolicy_Fail>(dest.def_nr,"def_nr",db);
+    ReadField<ErrorPolicy_Fail>(dest.weight,"weight",db);
 
 	db.reader->IncPtr(size);
 }
@@ -218,9 +218,9 @@ template <> void Structure :: Convert<Base> (
     ) const
 { 
 
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.prev,"*prev",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.next,"*next",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.object,"*object",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.prev,"*prev",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.next,"*next",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.object,"*object",db);
 
 	db.reader->IncPtr(size);
 }
@@ -232,7 +232,7 @@ template <> void Structure :: Convert<MTFace> (
     ) const
 { 
 
-    ReadFieldArray2<ErrorPolicy_Igno>(dest.uv,"uv",db);
+    ReadFieldArray2<ErrorPolicy_Fail>(dest.uv,"uv",db);
     ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
     ReadField<ErrorPolicy_Igno>(dest.mode,"mode",db);
     ReadField<ErrorPolicy_Igno>(dest.tile,"tile",db);
@@ -248,29 +248,29 @@ template <> void Structure :: Convert<Material> (
     ) const
 { 
 
-    ReadField<ErrorPolicy_Igno>(dest.id,"id",db);
-    ReadField<ErrorPolicy_Igno>(dest.r,"r",db);
-    ReadField<ErrorPolicy_Igno>(dest.g,"g",db);
-    ReadField<ErrorPolicy_Igno>(dest.b,"b",db);
-    ReadField<ErrorPolicy_Igno>(dest.specr,"specr",db);
-    ReadField<ErrorPolicy_Igno>(dest.specg,"specg",db);
-    ReadField<ErrorPolicy_Igno>(dest.specb,"specb",db);
-    ReadField<ErrorPolicy_Igno>(dest.ambir,"ambir",db);
-    ReadField<ErrorPolicy_Igno>(dest.ambig,"ambig",db);
-    ReadField<ErrorPolicy_Igno>(dest.ambib,"ambib",db);
+    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
+    ReadField<ErrorPolicy_Warn>(dest.r,"r",db);
+    ReadField<ErrorPolicy_Warn>(dest.g,"g",db);
+    ReadField<ErrorPolicy_Warn>(dest.b,"b",db);
+    ReadField<ErrorPolicy_Warn>(dest.specr,"specr",db);
+    ReadField<ErrorPolicy_Warn>(dest.specg,"specg",db);
+    ReadField<ErrorPolicy_Warn>(dest.specb,"specb",db);
+    ReadField<ErrorPolicy_Warn>(dest.ambir,"ambir",db);
+    ReadField<ErrorPolicy_Warn>(dest.ambig,"ambig",db);
+    ReadField<ErrorPolicy_Warn>(dest.ambib,"ambib",db);
     ReadField<ErrorPolicy_Igno>(dest.mirr,"mirr",db);
     ReadField<ErrorPolicy_Igno>(dest.mirg,"mirg",db);
     ReadField<ErrorPolicy_Igno>(dest.mirb,"mirb",db);
-    ReadField<ErrorPolicy_Igno>(dest.emit,"emit",db);
-    ReadField<ErrorPolicy_Igno>(dest.alpha,"alpha",db);
+    ReadField<ErrorPolicy_Warn>(dest.emit,"emit",db);
+    ReadField<ErrorPolicy_Warn>(dest.alpha,"alpha",db);
     ReadField<ErrorPolicy_Igno>(dest.ref,"ref",db);
     ReadField<ErrorPolicy_Igno>(dest.translucency,"translucency",db);
     ReadField<ErrorPolicy_Igno>(dest.roughness,"roughness",db);
     ReadField<ErrorPolicy_Igno>(dest.darkness,"darkness",db);
     ReadField<ErrorPolicy_Igno>(dest.refrac,"refrac",db);
     ReadFieldPtr<ErrorPolicy_Igno>(dest.group,"*group",db);
-    ReadField<ErrorPolicy_Igno>(dest.diff_shader,"diff_shader",db);
-    ReadField<ErrorPolicy_Igno>(dest.spec_shader,"spec_shader",db);
+    ReadField<ErrorPolicy_Warn>(dest.diff_shader,"diff_shader",db);
+    ReadField<ErrorPolicy_Warn>(dest.spec_shader,"spec_shader",db);
 
 	db.reader->IncPtr(size);
 }
@@ -282,21 +282,22 @@ template <> void Structure :: Convert<Mesh> (
     ) const
 { 
 
-    ReadField<ErrorPolicy_Igno>(dest.id,"id",db);
-    ReadField<ErrorPolicy_Igno>(dest.totface,"totface",db);
-    ReadField<ErrorPolicy_Igno>(dest.totedge,"totedge",db);
-    ReadField<ErrorPolicy_Igno>(dest.totvert,"totvert",db);
+    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
+    ReadField<ErrorPolicy_Fail>(dest.totface,"totface",db);
+    ReadField<ErrorPolicy_Fail>(dest.totedge,"totedge",db);
+    ReadField<ErrorPolicy_Fail>(dest.totvert,"totvert",db);
     ReadField<ErrorPolicy_Igno>(dest.subdiv,"subdiv",db);
     ReadField<ErrorPolicy_Igno>(dest.subdivr,"subdivr",db);
     ReadField<ErrorPolicy_Igno>(dest.subsurftype,"subsurftype",db);
     ReadField<ErrorPolicy_Igno>(dest.smoothresh,"smoothresh",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mface,"*mface",db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.mface,"*mface",db);
     ReadFieldPtr<ErrorPolicy_Igno>(dest.mtface,"*mtface",db);
     ReadFieldPtr<ErrorPolicy_Igno>(dest.tface,"*tface",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mvert,"*mvert",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.medge,"*medge",db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.mvert,"*mvert",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.medge,"*medge",db);
     ReadFieldPtr<ErrorPolicy_Igno>(dest.dvert,"*dvert",db);
     ReadFieldPtr<ErrorPolicy_Igno>(dest.mcol,"*mcol",db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.mat,"**mat",db);
 
 	db.reader->IncPtr(size);
 }
@@ -308,7 +309,7 @@ template <> void Structure :: Convert<MDeformVert> (
     ) const
 { 
 
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.dw,"*dw",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.dw,"*dw",db);
     ReadField<ErrorPolicy_Igno>(dest.totweight,"totweight",db);
 
 	db.reader->IncPtr(size);
@@ -321,7 +322,7 @@ template <> void Structure :: Convert<World> (
     ) const
 { 
 
-    ReadField<ErrorPolicy_Igno>(dest.id,"id",db);
+    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
 
 	db.reader->IncPtr(size);
 }
@@ -333,11 +334,11 @@ template <> void Structure :: Convert<MVert> (
     ) const
 { 
 
-    ReadFieldArray<ErrorPolicy_Igno>(dest.co,"co",db);
-    ReadFieldArray<ErrorPolicy_Igno>(dest.no,"no",db);
+    ReadFieldArray<ErrorPolicy_Fail>(dest.co,"co",db);
+    ReadFieldArray<ErrorPolicy_Fail>(dest.no,"no",db);
     ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-    ReadField<ErrorPolicy_Igno>(dest.mat_nr,"mat_nr",db);
-    ReadField<ErrorPolicy_Igno>(dest.bweight,"bweight",db);
+    ReadField<ErrorPolicy_Warn>(dest.mat_nr,"mat_nr",db);
+    ReadField<ErrorPolicy_Fail>(dest.bweight,"bweight",db);
 
 	db.reader->IncPtr(size);
 }
@@ -349,8 +350,8 @@ template <> void Structure :: Convert<MEdge> (
     ) const
 { 
 
-    ReadField<ErrorPolicy_Igno>(dest.v1,"v1",db);
-    ReadField<ErrorPolicy_Igno>(dest.v2,"v2",db);
+    ReadField<ErrorPolicy_Fail>(dest.v1,"v1",db);
+    ReadField<ErrorPolicy_Fail>(dest.v2,"v2",db);
     ReadField<ErrorPolicy_Igno>(dest.crease,"crease",db);
     ReadField<ErrorPolicy_Igno>(dest.bweight,"bweight",db);
     ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
@@ -365,8 +366,8 @@ template <> void Structure :: Convert<GroupObject> (
     ) const
 { 
 
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.prev,"*prev",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.next,"*next",db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.prev,"*prev",db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.next,"*next",db);
     ReadFieldPtr<ErrorPolicy_Igno>(dest.ob,"*ob",db);
 
 	db.reader->IncPtr(size);
@@ -392,7 +393,7 @@ template <> void Structure :: Convert<ID> (
     ) const
 { 
 
-    ReadFieldArray<ErrorPolicy_Igno>(dest.name,"name",db);
+    ReadFieldArray<ErrorPolicy_Warn>(dest.name,"name",db);
     ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
 
 	db.reader->IncPtr(size);
@@ -405,10 +406,10 @@ template <> void Structure :: Convert<MCol> (
     ) const
 { 
 
-    ReadField<ErrorPolicy_Igno>(dest.r,"r",db);
-    ReadField<ErrorPolicy_Igno>(dest.g,"g",db);
-    ReadField<ErrorPolicy_Igno>(dest.b,"b",db);
-    ReadField<ErrorPolicy_Igno>(dest.a,"a",db);
+    ReadField<ErrorPolicy_Fail>(dest.r,"r",db);
+    ReadField<ErrorPolicy_Fail>(dest.g,"g",db);
+    ReadField<ErrorPolicy_Fail>(dest.b,"b",db);
+    ReadField<ErrorPolicy_Fail>(dest.a,"a",db);
 
 	db.reader->IncPtr(size);
 }
@@ -420,8 +421,8 @@ template <> void Structure :: Convert<Image> (
     ) const
 { 
 
-    ReadField<ErrorPolicy_Igno>(dest.id,"id",db);
-    ReadFieldArray<ErrorPolicy_Igno>(dest.name,"name",db);
+    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
+    ReadFieldArray<ErrorPolicy_Warn>(dest.name,"name",db);
     ReadField<ErrorPolicy_Igno>(dest.ok,"ok",db);
     ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
     ReadField<ErrorPolicy_Igno>(dest.source,"source",db);
@@ -453,10 +454,10 @@ template <> void Structure :: Convert<Scene> (
     ) const
 { 
 
-    ReadField<ErrorPolicy_Igno>(dest.id,"id",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.camera,"*camera",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.world,"*world",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.basact,"*basact",db);
+    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.camera,"*camera",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.world,"*world",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.basact,"*basact",db);
     ReadField<ErrorPolicy_Igno>(dest.base,"base",db);
 
 	db.reader->IncPtr(size);
@@ -469,10 +470,10 @@ template <> void Structure :: Convert<Library> (
     ) const
 { 
 
-    ReadField<ErrorPolicy_Igno>(dest.id,"id",db);
-    ReadFieldArray<ErrorPolicy_Igno>(dest.name,"name",db);
-    ReadFieldArray<ErrorPolicy_Igno>(dest.filename,"filename",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.parent,"*parent",db);
+    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
+    ReadFieldArray<ErrorPolicy_Warn>(dest.name,"name",db);
+    ReadFieldArray<ErrorPolicy_Fail>(dest.filename,"filename",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.parent,"*parent",db);
 
 	db.reader->IncPtr(size);
 }
@@ -484,8 +485,8 @@ template <> void Structure :: Convert<Tex> (
     ) const
 { 
 
-    ReadField<ErrorPolicy_Igno>((int&)dest.type,"type",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.ima,"*ima",db);
+    ReadField<ErrorPolicy_Fail>((int&)dest.type,"type",db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.ima,"*ima",db);
 
 	db.reader->IncPtr(size);
 }
@@ -497,10 +498,10 @@ template <> void Structure :: Convert<Camera> (
     ) const
 { 
 
-    ReadField<ErrorPolicy_Igno>(dest.id,"id",db);
-    ReadField<ErrorPolicy_Igno>((int&)dest.type,"type",db);
-    ReadField<ErrorPolicy_Igno>((int&)dest.flag,"flag",db);
-    ReadField<ErrorPolicy_Igno>(dest.angle,"angle",db);
+    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
+    ReadField<ErrorPolicy_Warn>((int&)dest.type,"type",db);
+    ReadField<ErrorPolicy_Warn>((int&)dest.flag,"flag",db);
+    ReadField<ErrorPolicy_Warn>(dest.angle,"angle",db);
 
 	db.reader->IncPtr(size);
 }
diff --git a/code/BlenderScene.h b/code/BlenderScene.h
index 964857514..f9d9c5404 100644
--- a/code/BlenderScene.h
+++ b/code/BlenderScene.h
@@ -197,7 +197,7 @@ struct MDeformWeight : ElemBase  {
 // -------------------------------------------------------------------------------
 struct MDeformVert : ElemBase  {
 
-	boost::shared_array<MDeformWeight> dw WARN;
+	vector<MDeformWeight> dw WARN;
 	int totweight;
 };
 
@@ -238,13 +238,15 @@ struct Mesh : ElemBase {
 	short subsurftype;
 	short smoothresh;
 
-	boost::shared_array<MFace> mface FAIL;
-	boost::shared_array<MTFace> mtface;
-	boost::shared_array<TFace> tface;
-	boost::shared_array<MVert> mvert FAIL;
-	boost::shared_array<MEdge> medge WARN;
-	boost::shared_array<MDeformVert> dvert;
-	boost::shared_array<MCol> mcol;
+	vector<MFace> mface FAIL;
+	vector<MTFace> mtface;
+	vector<TFace> tface;
+	vector<MVert> mvert FAIL;
+	vector<MEdge> medge WARN;
+	vector<MDeformVert> dvert;
+	vector<MCol> mcol;
+
+	vector< boost::shared_ptr<Material> > mat FAIL;
 };
 
 // -------------------------------------------------------------------------------
diff --git a/scripts/BlenderImporter/genblenddna.py b/scripts/BlenderImporter/genblenddna.py
index 9f2f347b3..15187c21c 100644
--- a/scripts/BlenderImporter/genblenddna.py
+++ b/scripts/BlenderImporter/genblenddna.py
@@ -101,10 +101,13 @@ def main():
     flags = re.ASCII|re.DOTALL|re.MULTILINE
     #stripcoms = re.compile(r"/\*(.*?)*\/",flags)
     getstruct = re.compile(r"struct\s+(\w+?)\s*(:\s*ElemBase)?\s*\{(.*?)^\}\s*;",flags)
+    getsmartx = re.compile(r"(std\s*::\s*)?(vector)\s*<\s*(boost\s*::\s*)?shared_(ptr)\s*<\s*(\w+)\s*>\s*>\s*",flags)
     getsmartp = re.compile(r"(boost\s*::\s*)?shared_(ptr)\s*<\s*(\w+)\s*>\s*",flags)
-    getsmarta = re.compile(r"(boost\s*::\s*)?shared_(array)\s*<\s*(\w+)\s*>\s*",flags)
-    getpolicy = re.compile(r"\s*(WARN|FAIL|IGNO|)",flags)
+    getsmarta = re.compile(r"(std\s*::\s*)?(vector)\s*<\s*(\w+)\s*>\s*",flags)
+    getpolicy = re.compile(r"\s*(WARN|FAIL|IGNO)",flags)
     stripenum = re.compile(r"enum\s+(\w+)\s*{.*?\}\s*;",flags)
+
+    assert getsmartx and getsmartp and getsmarta and getpolicy and stripenum
     
     enums = set()
     #re.sub(stripcoms," ",input)
@@ -136,28 +139,27 @@ def main():
     for k,v in hits.items():
         out = []
         for line in v:
-            tok = line.split(None,1)
-            if len(tok) <= 1:
-                continue
+           
+            policy = "IGNO"
+            py = re.search(getpolicy,line) 
+            if not py is None:
+                policy = py.groups()[0]
+                line = re.sub(getpolicy,"",line)
 
-            #print(tok)
-
-            ty = re.match(getsmartp,tok[0]) or re.match(getsmarta,tok[0]) or tok[0]
-            if not isinstance(ty,str):
+            ty = re.match(getsmartx,line) or re.match(getsmartp,line)  or re.match(getsmarta,line) 
+            if ty is None:
+                ty = line.split(None,1)[0]
+            else:
                 if ty.groups()[1] == "ptr":
                     ty = ty.groups()[2] + "*"
-                elif ty.groups()[1] == "array":
-                    ty = ty.groups()[2] + "*"
+                elif ty.groups()[1] == "vector":
+                    ty = ty.groups()[-1] + ("*" if len(ty.groups()) == 3 else "**")
 
-            policy = "IGNO"
-            py = re.search(getpolicy,tok[1]) or tok[1]
-            if not isinstance(py,str):
-                policy = py.groups()[0]
-                py = re.sub(getpolicy,"",tok[1])
-
-            #print(py)
-            for m in py.split(','):
-                out.append((ty,m,policy))
+            #print(line)
+            sp = line.split(',')
+            out.append((ty,sp[0].split(None)[-1].strip(),policy))
+            for m in sp[1:]:
+                out.append((ty,m.strip(),policy))
                 
         v[:] = out
         print("Structure {0}".format(k))
diff --git a/test/models/BLEND/4Cubes4Mats_248.blend b/test/models/BLEND/4Cubes4Mats_248.blend
new file mode 100644
index 0000000000000000000000000000000000000000..9666254784f1be0b876799da3a7e83a4dde634cd
GIT binary patch
literal 136684
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%0A<vC*<H1slT!@`*IekT$#|sT@LA=W4
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
M_e@Sipum6s2X)Vhod5s;

literal 0
HcmV?d00001

diff --git a/tools/assimp_view/assimp_view.rc b/tools/assimp_view/assimp_view.rc
index 16e4f3e05..1e6eb432d 100644
--- a/tools/assimp_view/assimp_view.rc
+++ b/tools/assimp_view/assimp_view.rc
@@ -55,7 +55,7 @@ END
 
 IDD_DIALOGMAIN DIALOGEX 0, 0, 615, 485
 STYLE DS_SETFONT | DS_MODALFRAME | DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU
-EXSTYLE WS_EX_TOPMOST | WS_EX_ACCEPTFILES | WS_EX_WINDOWEDGE
+EXSTYLE WS_EX_ACCEPTFILES | WS_EX_WINDOWEDGE
 CAPTION "Open Asset Import Library - ModelViewer "
 MENU IDR_MENU1
 FONT 8, "Microsoft Sans Serif", 400, 0, 0x0