Merge branch 'master' of https://github.com/assimp/assimp

.gitignore

@@ -58,3 +58,4 @@ test/gtest/src/gtest-stamp/gtest-gitinfo.txt
 test/gtest/src/gtest-stamp/gtest-gitclone-lastrun.txt
 Assimp.opensdf
 contrib/zlib/CTestTestfile.cmake
+ipch/assimp_viewer-44bbbcd1/assimp_viewerd-ccc45335.ipch

CMakeLists.txt

@@ -1,3 +1,4 @@
+set(CMAKE_LEGACY_CYGWIN_WIN32 0) # Remove when CMake >= 2.8.4 is required
 cmake_minimum_required( VERSION 2.8 )
 PROJECT( Assimp )
 
@@ -61,9 +62,9 @@ if( CMAKE_COMPILER_IS_MINGW )
 endif()
 
 if((CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX) AND NOT CMAKE_COMPILER_IS_MINGW)
-    add_definitions(-fPIC) # this is a very important switch and some libraries seem now to have it....
+    set(CMAKE_CXX_FLAGS "-fPIC") # this is a very important switch and some libraries seem now to have it....
     # hide all not-exported symbols
-    add_definitions( -fvisibility=hidden -Wall )
+    set(CMAKE_CXX_FLAGS "-fvisibility=hidden -Wall" )
 elseif(MSVC)
     # enable multi-core compilation with MSVC
     add_definitions(/MP)

code/Assimp.cpp

@@ -42,18 +42,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the Plain-C API
  */
 
-#include "../include/assimp/cimport.h"
+#include <assimp/cimport.h>
-#include "../include/assimp/LogStream.hpp"
+#include <assimp/LogStream.hpp>
-#include "../include/assimp/DefaultLogger.hpp"
+#include <assimp/DefaultLogger.hpp>
-#include "../include/assimp/importerdesc.h"
+#include <assimp/Importer.hpp>
-#include "../include/assimp/scene.h"
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
 
 #include "GenericProperty.h"
 #include "CInterfaceIOWrapper.h"
-#include "Importer.h"
+#include "Importer.h"
-#include "Exceptional.h"
+#include "Exceptional.h"
-#include "ScenePrivate.h"
+#include "ScenePrivate.h"
-#include "BaseImporter.h"
+#include "BaseImporter.h"
 #include <list>
 
 // ------------------------------------------------------------------------------------------------
@@ -489,7 +490,7 @@ ASSIMP_API void aiSetImportPropertyInteger(aiPropertyStore* p, const char* szNam
 {
 	ASSIMP_BEGIN_EXCEPTION_REGION();
 	PropertyMap* pp = reinterpret_cast<PropertyMap*>(p);
-	SetGenericProperty<int>(pp->ints,szName,value,NULL);
+	SetGenericProperty<int>(pp->ints,szName,value);
 	ASSIMP_END_EXCEPTION_REGION(void);
 }
 
@@ -499,7 +500,7 @@ ASSIMP_API void aiSetImportPropertyFloat(aiPropertyStore* p, const char* szName,
 {
 	ASSIMP_BEGIN_EXCEPTION_REGION();
 	PropertyMap* pp = reinterpret_cast<PropertyMap*>(p);
-	SetGenericProperty<float>(pp->floats,szName,value,NULL);
+	SetGenericProperty<float>(pp->floats,szName,value);
 	ASSIMP_END_EXCEPTION_REGION(void);
 }
 
@@ -513,7 +514,7 @@ ASSIMP_API void aiSetImportPropertyString(aiPropertyStore* p, const char* szName
 	}
 	ASSIMP_BEGIN_EXCEPTION_REGION();
 	PropertyMap* pp = reinterpret_cast<PropertyMap*>(p);
-	SetGenericProperty<std::string>(pp->strings,szName,std::string(st->C_Str()),NULL);
+	SetGenericProperty<std::string>(pp->strings,szName,std::string(st->C_Str()));
 	ASSIMP_END_EXCEPTION_REGION(void);
 }
 
@@ -527,7 +528,7 @@ ASSIMP_API void aiSetImportPropertyMatrix(aiPropertyStore* p, const char* szName
 	}
 	ASSIMP_BEGIN_EXCEPTION_REGION();
 	PropertyMap* pp = reinterpret_cast<PropertyMap*>(p);
-	SetGenericProperty<aiMatrix4x4>(pp->matrices,szName,*mat,NULL);
+	SetGenericProperty<aiMatrix4x4>(pp->matrices,szName,*mat);
 	ASSIMP_END_EXCEPTION_REGION(void);
 }
 

code/BaseImporter.cpp

@@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "BaseImporter.h"
 #include "FileSystemFilter.h"
 #include "Importer.h"
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 #include "../include/assimp/scene.h"
 #include "../include/assimp/Importer.hpp"
 #include "../include/assimp/postprocess.h"

code/Bitmap.cpp

@@ -49,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "Bitmap.h"
 #include "../include/assimp/texture.h"
 #include "../include/assimp/IOStream.hpp"
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 
 namespace Assimp {
 

code/ByteSwapper.h

@@ -5,8 +5,8 @@ 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, 
+Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the 
+with or without modification, are permitted provided that the
 following conditions are met:
 
 * Redistributions of source code must retain the above
@@ -23,38 +23,38 @@ following conditions are met:
   derived from this software without specific prior
   written permission of the assimp team.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+"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 
+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 
+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 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+(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 Helper class tp perform various byte oder swappings 
+/** @file Helper class tp perform various byte oder swappings
    (e.g. little to big endian) */
-#ifndef AI_BYTESWAP_H_INC
+#ifndef AI_BYTESWAPPER_H_INC
-#define AI_BYTESWAP_H_INC
+#define AI_BYTESWAPPER_H_INC
 
 #include "../include/assimp/ai_assert.h"
 #include "../include/assimp/types.h"
 #include <stdint.h>
 
-#if _MSC_VER >= 1400 
+#if _MSC_VER >= 1400
 #include <stdlib.h>
 #endif
 
 namespace Assimp	{
 // --------------------------------------------------------------------------------------
 /** Defines some useful byte order swap routines.
- * 
+ *
  * This is required to read big-endian model formats on little-endian machines,
  * and vice versa. Direct use of this class is DEPRECATED. Use #StreamReader instead. */
 // --------------------------------------------------------------------------------------
@@ -167,7 +167,7 @@ public:
 	// ----------------------------------------------------------------------
 	//! Templatized ByteSwap
 	//! \returns param tOut as swapped
-	template<typename Type> 
+	template<typename Type>
 	static inline Type Swapped(Type tOut)
 	{
 		return _swapper<Type,sizeof(Type)>()(tOut);
@@ -180,28 +180,28 @@ private:
 
 template <typename T> struct ByteSwap::_swapper<T,2> {
 	T operator() (T tOut) {
-		Swap2(&tOut); 
+		Swap2(&tOut);
 		return tOut;
 	}
 };
 
 template <typename T> struct ByteSwap::_swapper<T,4> {
 	T operator() (T tOut) {
-		Swap4(&tOut); 
+		Swap4(&tOut);
 		return tOut;
 	}
 };
 
 template <typename T> struct ByteSwap::_swapper<T,8> {
 	T operator() (T tOut) {
-		Swap8(&tOut); 
+		Swap8(&tOut);
 		return tOut;
 	}
 };
 
 
 // --------------------------------------------------------------------------------------
-// ByteSwap macros for BigEndian/LittleEndian support 
+// ByteSwap macros for BigEndian/LittleEndian support
 // --------------------------------------------------------------------------------------
 #if (defined AI_BUILD_BIG_ENDIAN)
 #	define AI_LE(t)	(t)
@@ -250,7 +250,7 @@ struct ByteSwapper	{
 	}
 };
 
-template <typename T> 
+template <typename T>
 struct ByteSwapper<T,false>	{
 	void operator() (T*) {
 	}
@@ -272,7 +272,7 @@ struct Getter {
 	}
 };
 
-template <bool SwapEndianess, typename T> 
+template <bool SwapEndianess, typename T>
 struct Getter<SwapEndianess,T,false> {
 
 	void operator() (T* inout, bool /*le*/) {
@@ -283,4 +283,4 @@ struct Getter<SwapEndianess,T,false> {
 } // end Intern
 } // end Assimp
 
-#endif //!! AI_BYTESWAP_H_INC
+#endif //!! AI_BYTESWAPPER_H_INC

code/CMakeLists.txt

@@ -98,7 +98,7 @@ SET( Common_SRCS
 	ScenePrivate.h
 	PostStepRegistry.cpp
 	ImporterRegistry.cpp
-	ByteSwap.h
+	ByteSwapper.h
 	DefaultProgressHandler.h
 	DefaultIOStream.cpp
 	DefaultIOStream.h
@@ -784,7 +784,7 @@ if( MSVC )
   else()
     set(MSVC_PREFIX "vc130")
   endif()
-  set(LIBRARY_SUFFIX "${ASSIMP_LIBRARY_SUFFIX}-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library" FORCE)
+  set(LIBRARY_SUFFIX "${ASSIMP_LIBRARY_SUFFIX}-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library")
 endif()
 
 SET_TARGET_PROPERTIES( assimp PROPERTIES

code/ColladaHelper.h

@@ -513,6 +513,8 @@ struct Effect
 	// Scalar factory
 	float mShininess, mRefractIndex, mReflectivity;
 	float mTransparency;
+	bool mHasTransparency;
+	bool mRGBTransparency;
 
 	// local params referring to each other by their SID
 	typedef std::map<std::string, Collada::EffectParam> ParamLibrary;
@@ -533,7 +535,9 @@ struct Effect
 		, mShininess    (10.0f)
 		, mRefractIndex (1.f)
 		, mReflectivity (1.f)
-		, mTransparency (0.f)
+		, mTransparency (1.f)
+		, mHasTransparency (false)
+		, mRGBTransparency(false)
 		, mDoubleSided	(false)
 		, mWireframe    (false)
 		, mFaceted      (false)

code/ColladaLoader.cpp

@@ -117,6 +117,7 @@ void ColladaLoader::SetupProperties(const Importer* pImp)
 {
 	noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES,0) != 0;
 	ignoreUpDirection = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION,0) != 0;
+	invertTransparency = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_INVERT_TRANSPARENCY,0) != 0;
 }
 
 
@@ -1338,11 +1339,25 @@ void ColladaLoader::FillMaterials( const ColladaParser& pParser, aiScene* /*pSce
 		mat.AddProperty( &effect.mRefractIndex, 1, AI_MATKEY_REFRACTI);
 
 		// transparency, a very hard one. seemingly not all files are following the
-		// specification here .. but we can trick.
+		// specification here (1.0 transparency => completly opaque)...
-		if (effect.mTransparency >= 0.f && effect.mTransparency < 1.f) {
+		// therefore, we let the opportunity for the user to manually invert
-			effect.mTransparency = 1.f- effect.mTransparency;
+		// the transparency if necessary and we add preliminary support for RGB_ZERO mode
-			mat.AddProperty( &effect.mTransparency, 1, AI_MATKEY_OPACITY );
+		if(effect.mTransparency >= 0.f && effect.mTransparency <= 1.f) {
-			mat.AddProperty( &effect.mTransparent, 1, AI_MATKEY_COLOR_TRANSPARENT );
+			// Trying some support for RGB_ZERO mode
+			if(effect.mRGBTransparency) {
+				effect.mTransparency = 1.f - effect.mTransparent.a;
+			}
+			
+			// Global option
+			if(invertTransparency) {
+				effect.mTransparency = 1.f - effect.mTransparency;
+			}
+
+			// Is the material finally transparent ?
+			if (effect.mHasTransparency || effect.mTransparency < 1.f) {
+				mat.AddProperty( &effect.mTransparency, 1, AI_MATKEY_OPACITY );
+				mat.AddProperty( &effect.mTransparent, 1, AI_MATKEY_COLOR_TRANSPARENT );
+			}
 		}
 
 		// add textures, if given

code/ColladaLoader.h

@@ -241,6 +241,7 @@ protected:
 
 	bool noSkeletonMesh;
 	bool ignoreUpDirection;
+	bool invertTransparency;
 
 	/** Used by FindNameForNode() to generate unique node names */
 	unsigned int mNodeNameCounter;

code/ColladaParser.cpp

@@ -46,6 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER
 
+#include <sstream>
 #include "ColladaParser.h"
 #include "fast_atof.h"
 #include "ParsingUtils.h"
@@ -1230,6 +1231,14 @@ void ColladaParser::ReadEffectProfileCommon( Collada::Effect& pEffect)
 				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"))
@@ -1987,12 +1996,12 @@ void ColladaParser::ReadIndexData( Mesh* pMesh)
 			break;
 		}
 	}
-
+
 #ifdef ASSIMP_BUILD_DEBUG  
 	if (primType != Prim_TriFans && primType != Prim_TriStrips) {
 		ai_assert(actualPrimitives == numPrimitives);
 	}
-#endif
+#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;

code/Exporter.cpp

@@ -513,34 +513,30 @@ ExportProperties::ExportProperties(const ExportProperties &other)
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-void ExportProperties :: SetPropertyInteger(const char* szName, int iValue, 
+bool ExportProperties :: SetPropertyInteger(const char* szName, int iValue)
-	bool* bWasExisting /*= NULL*/)
 {
-	SetGenericProperty<int>(mIntProperties, szName,iValue,bWasExisting);
+	return SetGenericProperty<int>(mIntProperties, szName,iValue);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-void ExportProperties :: SetPropertyFloat(const char* szName, float iValue, 
+bool ExportProperties :: SetPropertyFloat(const char* szName, float iValue)
-	bool* bWasExisting /*= NULL*/)
 {
-	SetGenericProperty<float>(mFloatProperties, szName,iValue,bWasExisting);
+	return SetGenericProperty<float>(mFloatProperties, szName,iValue);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-void ExportProperties :: SetPropertyString(const char* szName, const std::string& value, 
+bool ExportProperties :: SetPropertyString(const char* szName, const std::string& value)
-	bool* bWasExisting /*= NULL*/)
 {
-	SetGenericProperty<std::string>(mStringProperties, szName,value,bWasExisting);
+	return SetGenericProperty<std::string>(mStringProperties, szName,value);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-void ExportProperties :: SetPropertyMatrix(const char* szName, const aiMatrix4x4& value, 
+bool ExportProperties :: SetPropertyMatrix(const char* szName, const aiMatrix4x4& value)
-	bool* bWasExisting /*= NULL*/)
 {
-	SetGenericProperty<aiMatrix4x4>(mMatrixProperties, szName,value,bWasExisting);
+	return SetGenericProperty<aiMatrix4x4>(mMatrixProperties, szName,value);
 }
 
 // ------------------------------------------------------------------------------------------------

code/FBXBinaryTokenizer.cpp

@@ -5,8 +5,8 @@ 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, 
+Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the 
+with or without modification, are permitted provided that the
 following conditions are met:
 
 * Redistributions of source code must retain the above
@@ -23,16 +23,16 @@ following conditions are met:
   derived from this software without specific prior
   written permission of the assimp team.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+"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 
+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 
+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 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
@@ -50,7 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../include/assimp/defs.h"
 #include <stdint.h>
 #include "Exceptional.h"
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 
 namespace Assimp {
 namespace FBX {
@@ -58,7 +58,7 @@ namespace FBX {
 
 // ------------------------------------------------------------------------------------------------
 Token::Token(const char* sbegin, const char* send, TokenType type, unsigned int offset)
-	: 
+	:
 	#ifdef DEBUG
 	contents(sbegin, static_cast<size_t>(send-sbegin)),
 	#endif
@@ -108,7 +108,7 @@ uint32_t ReadWord(const char* input, const char*& cursor, const char* end)
 {
 	if(Offset(cursor, end) < 4) {
 		TokenizeError("cannot ReadWord, out of bounds",input, cursor);
-	} 
+	}
 
 	uint32_t word = *reinterpret_cast<const uint32_t*>(cursor);
 	AI_SWAP4(word);
@@ -124,7 +124,7 @@ uint8_t ReadByte(const char* input, const char*& cursor, const char* end)
 {
 	if(Offset(cursor, end) < 1) {
 		TokenizeError("cannot ReadByte, out of bounds",input, cursor);
-	} 
+	}
 
 	uint8_t word = *reinterpret_cast<const uint8_t*>(cursor);
 	++cursor;
@@ -134,14 +134,14 @@ uint8_t ReadByte(const char* input, const char*& cursor, const char* end)
 
 
 // ------------------------------------------------------------------------------------------------
-unsigned int ReadString(const char*& sbegin_out, const char*& send_out, const char* input, const char*& cursor, const char* end, 
+unsigned int ReadString(const char*& sbegin_out, const char*& send_out, const char* input, const char*& cursor, const char* end,
 	bool long_length = false,
 	bool allow_null = false)
 {
 	const uint32_t len_len = long_length ? 4 : 1;
 	if(Offset(cursor, end) < len_len) {
 		TokenizeError("cannot ReadString, out of bounds reading length",input, cursor);
-	} 
+	}
 
 	const uint32_t length = long_length ? ReadWord(input, cursor, end) : ReadByte(input, cursor, end);
 
@@ -172,7 +172,7 @@ void ReadData(const char*& sbegin_out, const char*& send_out, const char* input,
 {
 	if(Offset(cursor, end) < 1) {
 		TokenizeError("cannot ReadData, out of bounds reading length",input, cursor);
-	} 
+	}
 
 	const char type = *cursor;
 	sbegin_out = cursor++;
@@ -211,14 +211,14 @@ void ReadData(const char*& sbegin_out, const char*& send_out, const char* input,
 		// note: do not write cursor += ReadWord(...cursor) as this would be UB
 
 		// raw binary data
-	case 'R':	
+	case 'R':
 	{
 		const uint32_t length = ReadWord(input, cursor, end);
 		cursor += length;
 		break;
 	}
 
-	case 'b': 
+	case 'b':
 		// TODO: what is the 'b' type code? Right now we just skip over it /
 		// take the full range we could get
 		cursor = end;
@@ -229,7 +229,7 @@ void ReadData(const char*& sbegin_out, const char*& send_out, const char* input,
 	case 'd':
 	case 'l':
 	case 'i':	{
-	
+
 		const uint32_t length = ReadWord(input, cursor, end);
 		const uint32_t encoding = ReadWord(input, cursor, end);
 
@@ -259,7 +259,7 @@ void ReadData(const char*& sbegin_out, const char*& send_out, const char* input,
 			}
 		}
 		// zip/deflate algorithm (encoding==1)? take given length. anything else? die
-		else if (encoding != 1) {			
+		else if (encoding != 1) {
 			TokenizeError("cannot ReadData, unknown encoding",input, cursor);
 		}
 		cursor += comp_len;
@@ -279,7 +279,7 @@ void ReadData(const char*& sbegin_out, const char*& send_out, const char* input,
 
 	if(cursor > end) {
 		TokenizeError("cannot ReadData, the remaining size is too small for the data type: " + std::string(&type, 1),input, cursor);
-	} 
+	}
 
 	// the type code is contained in the returned range
 	send_out = cursor;
@@ -291,10 +291,10 @@ bool ReadScope(TokenList& output_tokens, const char* input, const char*& cursor,
 {
 	// the first word contains the offset at which this block ends
 	const uint32_t end_offset = ReadWord(input, cursor, end);
-	
+
 	// we may get 0 if reading reached the end of the file -
-	// fbx files have a mysterious extra footer which I don't know 
+	// fbx files have a mysterious extra footer which I don't know
-	// how to extract any information from, but at least it always 
+	// how to extract any information from, but at least it always
 	// starts with a 0.
 	if(!end_offset) {
 		return false;

code/FBXParser.cpp

@@ -5,8 +5,8 @@ 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, 
+Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the 
+with or without modification, are permitted provided that the
 following conditions are met:
 
 * Redistributions of source code must retain the above
@@ -23,16 +23,16 @@ following conditions are met:
   derived from this software without specific prior
   written permission of the assimp team.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+"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 
+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 
+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 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
@@ -59,7 +59,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "ParsingUtils.h"
 #include "fast_atof.h"
 #include <boost/foreach.hpp>
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 
 using namespace Assimp;
 using namespace Assimp::FBX;
@@ -189,7 +189,7 @@ Scope::Scope(Parser& parser,bool topLevel)
 		TokenPtr t = parser.CurrentToken();
 		if (t->Type() != TokenType_OPEN_BRACKET) {
 			ParseError("expected open bracket",t);
-		}	
+		}
 	}
 
 	TokenPtr n = parser.AdvanceToNextToken();
@@ -384,7 +384,7 @@ float ParseTokenAsFloat(const Token& t, const char*& err_out)
 	}
 
 	// need to copy the input string to a temporary buffer
-	// first - next in the fbx token stream comes ',', 
+	// first - next in the fbx token stream comes ',',
 	// which fast_atof could interpret as decimal point.
 #define MAX_FLOAT_LENGTH 31
 	char temp[MAX_FLOAT_LENGTH + 1];
@@ -515,7 +515,7 @@ namespace {
 
 // ------------------------------------------------------------------------------------------------
 // read the type code and element count of a binary data array and stop there
-void ReadBinaryDataArrayHead(const char*& data, const char* end, char& type, uint32_t& count, 
+void ReadBinaryDataArrayHead(const char*& data, const char* end, char& type, uint32_t& count,
 	const Element& el)
 {
 	if (static_cast<size_t>(end-data) < 5) {
@@ -536,8 +536,8 @@ void ReadBinaryDataArrayHead(const char*& data, const char* end, char& type, uin
 
 // ------------------------------------------------------------------------------------------------
 // read binary data array, assume cursor points to the 'compression mode' field (i.e. behind the header)
-void ReadBinaryDataArray(char type, uint32_t count, const char*& data, const char* end, 
+void ReadBinaryDataArray(char type, uint32_t count, const char*& data, const char* end,
-	std::vector<char>& buff, 
+	std::vector<char>& buff,
 	const Element& /*el*/)
 {
 	BE_NCONST uint32_t encmode = SafeParse<uint32_t>(data, end);
@@ -581,7 +581,7 @@ void ReadBinaryDataArray(char type, uint32_t count, const char*& data, const cha
 	else if(encmode == 1) {
 		// zlib/deflate, next comes ZIP head (0x78 0x01)
 		// see http://www.ietf.org/rfc/rfc1950.txt
-		
+
 		z_stream zstream;
 		zstream.opaque = Z_NULL;
 		zstream.zalloc = Z_NULL;
@@ -631,7 +631,7 @@ void ParseVectorDataArray(std::vector<aiVector3D>& out, const Element& el)
 	if(tok.empty()) {
 		ParseError("unexpected empty element",&el);
 	}
-	
+
 	if(tok[0]->IsBinary()) {
 		const char* data = tok[0]->begin(), *end = tok[0]->end();
 
@@ -653,7 +653,7 @@ void ParseVectorDataArray(std::vector<aiVector3D>& out, const Element& el)
 
 		std::vector<char> buff;
 		ReadBinaryDataArray(type, count, data, end, buff, el);
-		
+
 		ai_assert(data == end);
 		ai_assert(buff.size() == count * (type == 'd' ? 8 : 4));
 
@@ -1095,7 +1095,7 @@ void ParseVectorDataArray(std::vector<uint64_t>& out, const Element& el)
 
 	for (TokenList::const_iterator it = a.Tokens().begin(), end = a.Tokens().end(); it != end; ) {
 		const uint64_t ival = ParseTokenAsID(**it++);
-		
+
 		out.push_back(ival);
 	}
 }
@@ -1211,7 +1211,7 @@ std::string ParseTokenAsString(const Token& t)
 
 // ------------------------------------------------------------------------------------------------
 // extract a required element from a scope, abort if the element cannot be found
-const Element& GetRequiredElement(const Scope& sc, const std::string& index, const Element* element /*= NULL*/) 
+const Element& GetRequiredElement(const Scope& sc, const std::string& index, const Element* element /*= NULL*/)
 {
 	const Element* el = sc[index];
 	if(!el) {
@@ -1249,7 +1249,7 @@ const Token& GetRequiredToken(const Element& el, unsigned int index)
 
 // ------------------------------------------------------------------------------------------------
 // wrapper around ParseTokenAsID() with ParseError handling
-uint64_t ParseTokenAsID(const Token& t) 
+uint64_t ParseTokenAsID(const Token& t)
 {
 	const char* err;
 	const uint64_t i = ParseTokenAsID(t,err);
@@ -1316,4 +1316,3 @@ int64_t ParseTokenAsInt64(const Token& t)
 } // !Assimp
 
 #endif
-

code/GenericProperty.h

@@ -49,22 +49,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ------------------------------------------------------------------------------------------------
 template <class T>
-inline void SetGenericProperty(std::map< unsigned int, T >& list, 
+inline bool SetGenericProperty(std::map< unsigned int, T >& list, 
-	const char* szName, const T& value, bool* bWasExisting = NULL)
+	const char* szName, const T& value)
 {
 	ai_assert(NULL != szName);
 	const uint32_t hash = SuperFastHash(szName);
 
 	typename std::map<unsigned int, T>::iterator it = list.find(hash);
 	if (it == list.end())	{
-		if (bWasExisting)
-			*bWasExisting = false;
 		list.insert(std::pair<unsigned int, T>( hash, value ));
-		return;
+		return false;
 	}
 	(*it).second = value;
-	if (bWasExisting)
+	return true;
-		*bWasExisting = true;
 }
 
 // ------------------------------------------------------------------------------------------------

code/IFF.h

@@ -1,5 +1,3 @@
-
-
 // Definitions for the Interchange File Format (IFF)
 // Alexander Gessler, 2006
 // Adapted to Assimp August 2008
@@ -7,7 +5,7 @@
 #ifndef AI_IFF_H_INCLUDED
 #define AI_IFF_H_INCLUDED
 
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 
 namespace Assimp	{
 namespace IFF		{
@@ -81,12 +79,12 @@ inline SubChunkHeader LoadSubChunk(uint8_t*& outFile)
 
 /////////////////////////////////////////////////////////////////////////////////
 //! Read the file header and return the type of the file and its size
-//! @param outFile Pointer to the file data. The buffer must at 
+//! @param outFile Pointer to the file data. The buffer must at
 //!   least be 12 bytes large.
 //! @param fileType Receives the type of the file
 //! @return 0 if everything was OK, otherwise an error message
 /////////////////////////////////////////////////////////////////////////////////
-inline const char* ReadHeader(uint8_t* outFile, uint32_t& fileType) 
+inline const char* ReadHeader(uint8_t* outFile, uint32_t& fileType)
 {
 	ChunkHeader head = LoadChunk(outFile);
 	if(AI_IFF_FOURCC_FORM != head.type)

code/Importer.cpp

@@ -925,42 +925,46 @@ void Importer::GetExtensionList(aiString& szOut) const
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-void Importer::SetPropertyInteger(const char* szName, int iValue, 
+bool Importer::SetPropertyInteger(const char* szName, int iValue)
-	bool* bWasExisting /*= NULL*/)
 {
+	bool existing;
 	ASSIMP_BEGIN_EXCEPTION_REGION();
-		SetGenericProperty<int>(pimpl->mIntProperties, szName,iValue,bWasExisting);	
+		existing = SetGenericProperty<int>(pimpl->mIntProperties, szName,iValue);	
-	ASSIMP_END_EXCEPTION_REGION(void);
+	ASSIMP_END_EXCEPTION_REGION(bool);
+	return existing;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-void Importer::SetPropertyFloat(const char* szName, float iValue, 
+bool Importer::SetPropertyFloat(const char* szName, float iValue)
-	bool* bWasExisting /*= NULL*/)
 {
+	bool exising;
 	ASSIMP_BEGIN_EXCEPTION_REGION();
-		SetGenericProperty<float>(pimpl->mFloatProperties, szName,iValue,bWasExisting);	
+		exising = SetGenericProperty<float>(pimpl->mFloatProperties, szName,iValue);	
-	ASSIMP_END_EXCEPTION_REGION(void);
+	ASSIMP_END_EXCEPTION_REGION(bool);
+	return exising;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-void Importer::SetPropertyString(const char* szName, const std::string& value, 
+bool Importer::SetPropertyString(const char* szName, const std::string& value)
-	bool* bWasExisting /*= NULL*/)
 {
+	bool exising;
 	ASSIMP_BEGIN_EXCEPTION_REGION();
-		SetGenericProperty<std::string>(pimpl->mStringProperties, szName,value,bWasExisting);	
+		exising = SetGenericProperty<std::string>(pimpl->mStringProperties, szName,value);	
-	ASSIMP_END_EXCEPTION_REGION(void);
+	ASSIMP_END_EXCEPTION_REGION(bool);
+	return exising;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-void Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value, 
+bool Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value)
-	bool* bWasExisting /*= NULL*/)
 {
+	bool exising;
 	ASSIMP_BEGIN_EXCEPTION_REGION();
-	SetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties, szName,value,bWasExisting);	
+		exising = SetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties, szName,value);	
-	ASSIMP_END_EXCEPTION_REGION(void);
+	ASSIMP_END_EXCEPTION_REGION(bool);
+	return exising;
 }
 
 // ------------------------------------------------------------------------------------------------

code/LWOLoader.cpp

@@ -50,7 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "LWOLoader.h"
 #include "StringComparison.h"
 #include "SGSpatialSort.h"
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 #include "ProcessHelper.h"
 #include "ConvertToLHProcess.h"
 #include <boost/scoped_ptr.hpp>

code/LWOMaterial.cpp

@@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // internal headers
 #include "LWOLoader.h"
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 #include <boost/static_assert.hpp>
 
 

code/MD2Loader.cpp

@@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the MD2 importer class */
 #include "MD2Loader.h"
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 #include "MD2NormalTable.h" // shouldn't be included by other units
 #include "../include/assimp/DefaultLogger.hpp"
 #include "../include/assimp/Importer.hpp"

code/MD2Loader.h

@@ -5,8 +5,8 @@ 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, 
+Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the 
+with or without modification, are permitted provided that the
 following conditions are met:
 
 * Redistributions of source code must retain the above
@@ -23,16 +23,16 @@ following conditions are met:
   derived from this software without specific prior
   written permission of the assimp team.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+"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 
+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 
+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 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
@@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "BaseImporter.h"
 #include "../include/assimp/types.h"
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 
 #include "MD2FileData.h"
 struct aiNode;
@@ -69,7 +69,7 @@ public:
 public:
 
 	// -------------------------------------------------------------------
-	/** Returns whether the class can handle the format of the given file. 
+	/** Returns whether the class can handle the format of the given file.
 	* See BaseImporter::CanRead() for details.	*/
 	bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
 		bool checkSig) const;
@@ -91,10 +91,10 @@ protected:
 	const aiImporterDesc* GetInfo () const;
 
 	// -------------------------------------------------------------------
-	/** Imports the given file into the given scene structure. 
+	/** Imports the given file into the given scene structure.
 	* See BaseImporter::InternReadFile() for details
 	*/
-	void InternReadFile( const std::string& pFile, aiScene* pScene, 
+	void InternReadFile( const std::string& pFile, aiScene* pScene,
 		IOSystem* pIOHandler);
 
 

code/MD3Loader.cpp

@@ -52,7 +52,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_MD3_IMPORTER
 
 #include "MD3Loader.h"
-#include "ByteSwap.h"
 #include "SceneCombiner.h"
 #include "GenericProperty.h"
 #include "RemoveComments.h"
@@ -564,7 +563,7 @@ bool MD3Importer::ReadMultipartFile()
 
 		// ensure we won't try to load ourselves recursively
 		BatchLoader::PropertyMap props;
-		SetGenericProperty( props.ints, AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART, 0, NULL);
+		SetGenericProperty( props.ints, AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART, 0);
 
 		// now read these three files
 		BatchLoader batch(mIOHandler);

code/MD3Loader.h

@@ -5,8 +5,8 @@ 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, 
+Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the 
+with or without modification, are permitted provided that the
 following conditions are met:
 
 * Redistributions of source code must retain the above
@@ -23,16 +23,16 @@ following conditions are met:
   derived from this software without specific prior
   written permission of the assimp team.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+"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 
+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 
+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 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
@@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_MD3LOADER_H_INCLUDED
 
 #include "BaseImporter.h"
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 #include "MD3FileData.h"
 #include "StringComparison.h"
 #include "../include/assimp/types.h"
@@ -99,7 +99,7 @@ enum ShaderCullMode
 enum BlendFunc
 {
 	BLEND_NONE,
-	BLEND_GL_ONE, 
+	BLEND_GL_ONE,
 	BLEND_GL_ZERO,
 	BLEND_GL_DST_COLOR,
 	BLEND_GL_ONE_MINUS_DST_COLOR,
@@ -114,7 +114,7 @@ enum AlphaTestFunc
 {
 	AT_NONE,
 	AT_GT0,
-	AT_LT128, 
+	AT_LT128,
 	AT_GE128
 };
 
@@ -223,7 +223,7 @@ public:
 public:
 
 	// -------------------------------------------------------------------
-	/** Returns whether the class can handle the format of the given file. 
+	/** Returns whether the class can handle the format of the given file.
 	* See BaseImporter::CanRead() for details.	*/
 	bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
 		bool checkSig) const;
@@ -245,10 +245,10 @@ protected:
 	const aiImporterDesc* GetInfo () const;
 
 	// -------------------------------------------------------------------
-	/** Imports the given file into the given scene structure. 
+	/** Imports the given file into the given scene structure.
 	 * See BaseImporter::InternReadFile() for details
 	 */
-	void InternReadFile( const std::string& pFile, aiScene* pScene, 
+	void InternReadFile( const std::string& pFile, aiScene* pScene,
 		IOSystem* pIOHandler);
 
 	// -------------------------------------------------------------------
@@ -281,7 +281,7 @@ protected:
 	 *  @param[in] header_path Base path specified in MD3 header
 	 *  @param[out] out Receives the converted output string
 	 */
-	void ConvertPath(const char* texture_name, const char* header_path, 
+	void ConvertPath(const char* texture_name, const char* header_path,
 		std::string& out) const;
 
 protected:

code/MDCLoader.h

@@ -5,8 +5,8 @@ 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, 
+Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the 
+with or without modification, are permitted provided that the
 following conditions are met:
 
 * Redistributions of source code must retain the above
@@ -23,23 +23,23 @@ following conditions are met:
   derived from this software without specific prior
   written permission of the assimp team.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+"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 
+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 
+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 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+(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  MDCLoader.h
- *  @brief Definition of the MDC importer class. 
+ *  @brief Definition of the MDC importer class.
  */
 #ifndef AI_MDCLOADER_H_INCLUDED
 #define AI_MDCLOADER_H_INCLUDED
@@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "BaseImporter.h"
 #include "MDCFileData.h"
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 
 namespace Assimp	{
 using namespace MDC;
@@ -66,7 +66,7 @@ public:
 public:
 
 	// -------------------------------------------------------------------
-	/** Returns whether the class can handle the format of the given file. 
+	/** Returns whether the class can handle the format of the given file.
 	* See BaseImporter::CanRead() for details.	*/
 	bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
 		bool checkSig) const;
@@ -87,7 +87,7 @@ protected:
 	const aiImporterDesc* GetInfo () const;
 
 	// -------------------------------------------------------------------
-	/** Imports the given file into the given scene structure. 
+	/** Imports the given file into the given scene structure.
 	* See BaseImporter::InternReadFile() for details
 	*/
 	void InternReadFile( const std::string& pFile, aiScene* pScene,
@@ -125,4 +125,3 @@ protected:
 } // end of namespace Assimp
 
 #endif // AI_3DSIMPORTER_H_INC
-

code/MDLFileData.h

@@ -5,8 +5,8 @@ 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, 
+Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the 
+with or without modification, are permitted provided that the
 following conditions are met:
 
 * Redistributions of source code must retain the above
@@ -23,16 +23,16 @@ following conditions are met:
   derived from this software without specific prior
   written permission of the assimp team.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+"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 
+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 
+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 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
@@ -41,7 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /**
  * @file  MDLFileData.h
- * @brief Definition of in-memory structures for the MDL file format. 
+ * @brief Definition of in-memory structures for the MDL file format.
  *
  * The specification has been taken from various sources on the internet.
  * - http://tfc.duke.free.fr/coding/mdl-specs-en.html
@@ -52,7 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_MDLFILEHELPER_H_INC
 #define AI_MDLFILEHELPER_H_INC
 
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 #include "./../include/assimp/anim.h"
 #include "./../include/assimp/mesh.h"
 #include "./../include/assimp/Compiler/pushpack1.h"
@@ -99,13 +99,13 @@ namespace MDL	{
 #	define AI_MDL_MAX_FRAMES			256
 #endif
 #if (!defined AI_MDL_MAX_UVS)
-#	define AI_MDL_MAX_UVS				1024	
+#	define AI_MDL_MAX_UVS				1024
 #endif
 #if (!defined AI_MDL_MAX_VERTS)
 #	define AI_MDL_MAX_VERTS				1024
 #endif
 #if (!defined AI_MDL_MAX_TRIANGLES)
-#	define AI_MDL_MAX_TRIANGLES			2048	
+#	define AI_MDL_MAX_TRIANGLES			2048
 #endif
 
 // material key that is set for dummy materials that are
@@ -121,47 +121,47 @@ namespace MDL	{
 struct Header
 {
 	//! magic number: "IDPO"
-	uint32_t ident;          
+	uint32_t ident;
 
 	//! version number: 6
-	int32_t version;          
+	int32_t version;
 
 	//! scale factors for each axis
-	aiVector3D scale;				
+	aiVector3D scale;
 
 	//! translation factors for each axis
-	aiVector3D translate;	
+	aiVector3D translate;
 
 	//! bounding radius of the mesh
 	float boundingradius;
-	 
+
 	//! Position of the viewer's exe. Ignored
 	aiVector3D vEyePos;
 
 	//! Number of textures
-	int32_t num_skins;       
+	int32_t num_skins;
 
 	//! Texture width in pixels
 	int32_t skinwidth;
 
 	//! Texture height in pixels
-	int32_t skinheight;       
+	int32_t skinheight;
 
 	//! Number of vertices contained in the file
-	int32_t num_verts;       
+	int32_t num_verts;
 
 	//! Number of triangles contained in the file
-	int32_t num_tris;         
+	int32_t num_tris;
 
 	//! Number of frames contained in the file
-	int32_t num_frames;      
+	int32_t num_frames;
 
 	//! 0 = synchron, 1 = random . Ignored
 	//! (MDLn formats: number of texture coordinates)
-	int32_t synctype;         
+	int32_t synctype;
 
 	//! State flag
-	int32_t flags;     
+	int32_t flags;
 
 	//! Could be the total size of the file (and not a float)
 	float size;
@@ -175,10 +175,10 @@ struct Header
 struct Header_MDL7
 {
 	//! magic number: "MDL7"
-	char	ident[4];		
+	char	ident[4];
 
 	//! Version number. Ignored
-	int32_t	version;		
+	int32_t	version;
 
 	//! Number of bones in file
 	uint32_t	bones_num;
@@ -187,13 +187,13 @@ struct Header_MDL7
 	uint32_t	groups_num;
 
 	//! Size of data in the file
-	uint32_t	data_size;	
+	uint32_t	data_size;
 
 	//! Ignored. Used to store entity specific information
-	int32_t	entlump_size;	
+	int32_t	entlump_size;
 
 	//! Ignored. Used to store MED related data
-	int32_t	medlump_size;	
+	int32_t	medlump_size;
 
 	//! Size of the Bone_MDL7 data structure used in the file
 	uint16_t bone_stc_size;
@@ -237,7 +237,7 @@ struct Bone_MDL7
 	//! Index of the parent bone of *this* bone. 0xffff means:
 	//! "hey, I have no parent, I'm an orphan"
 	uint16_t parent_index;
-	uint8_t _unused_[2]; 
+	uint8_t _unused_[2];
 
 	//! Relative position of the bone (relative to the
 	//! parent bone)
@@ -270,21 +270,21 @@ struct Bone_MDL7
 struct Group_MDL7
 {
 	//! = '1' -> triangle based Mesh
-	unsigned char	typ;		
+	unsigned char	typ;
 
 	int8_t	deformers;
 	int8_t	max_weights;
 	int8_t	_unused_;
 
 	//! size of data for this group in bytes ( MD7_GROUP stc. included).
-	int32_t	groupdata_size; 
+	int32_t	groupdata_size;
 	char	name[AI_MDL7_MAX_GROUPNAMESIZE];
 
 	//! Number of skins
 	int32_t	numskins;
 
 	//! Number of texture coordinates
-	int32_t	num_stpts;	
+	int32_t	num_stpts;
 
 	//! Number of triangles
 	int32_t	numtris;
@@ -327,7 +327,7 @@ struct Deformer_MDL7
 struct DeformerElement_MDL7
 {
 	//! bei deformer_typ==0 (==bones) element_index == bone index
-	int32_t	element_index;		
+	int32_t	element_index;
 	char	element_name[AI_MDL7_MAX_BONENAMESIZE];
 	int32_t	weights;
 } PACK_STRUCT;
@@ -340,7 +340,7 @@ struct DeformerElement_MDL7
 struct DeformerWeight_MDL7
 {
 	//! for deformer_typ==0 (==bones) index == vertex index
-	int32_t	index;				
+	int32_t	index;
 	float	weight;
 } PACK_STRUCT;
 
@@ -364,19 +364,19 @@ struct ColorValue_MDL7
 struct Material_MDL7
 {
 	//! Diffuse base color of the material
-	ColorValue_MDL7	Diffuse;        
+	ColorValue_MDL7	Diffuse;
 
 	//! Ambient base color of the material
-    ColorValue_MDL7	Ambient;  
+    ColorValue_MDL7	Ambient;
 
 	//! Specular base color of the material
-    ColorValue_MDL7	Specular;  
+    ColorValue_MDL7	Specular;
 
 	//! Emissive base color of the material
-    ColorValue_MDL7	Emissive; 
+    ColorValue_MDL7	Emissive;
 
 	//! Phong power
-    float			Power;         
+    float			Power;
 } PACK_STRUCT;
 
 
@@ -391,16 +391,16 @@ struct Skin
 	//! fore the size of the data to skip:
 	//-------------------------------------------------------
 	//! 2 for 565 RGB,
-	//! 3 for 4444 ARGB, 
+	//! 3 for 4444 ARGB,
-	//! 10 for 565 mipmapped, 
+	//! 10 for 565 mipmapped,
 	//! 11 for 4444 mipmapped (bpp = 2),
-	//! 12 for 888 RGB mipmapped (bpp = 3), 
+	//! 12 for 888 RGB mipmapped (bpp = 3),
 	//! 13 for 8888 ARGB mipmapped (bpp = 4)
 	//-------------------------------------------------------
-	int32_t group;      
+	int32_t group;
 
 	//! Texture data
-	uint8_t *data;  
+	uint8_t *data;
 } PACK_STRUCT;
 
 
@@ -411,8 +411,8 @@ struct Skin
  */
 struct Skin_MDL5
 {
-	int32_t size, width, height;      
+	int32_t size, width, height;
-	uint8_t *data;  
+	uint8_t *data;
 } PACK_STRUCT;
 
 // maximum length of texture file name
@@ -430,7 +430,7 @@ struct Skin_MDL7
 	int8_t			_unused_[3];
 	int32_t			width;
 	int32_t			height;
-	char			texture_name[AI_MDL7_MAX_TEXNAMESIZE];	
+	char			texture_name[AI_MDL7_MAX_TEXNAMESIZE];
 } PACK_STRUCT;
 
 // -------------------------------------------------------------------------------------
@@ -463,16 +463,16 @@ struct ARGB4
 struct GroupSkin
 {
 	//! 0 = single (Skin), 1 = group (GroupSkin)
-    int32_t group;     
+    int32_t group;
 
 	//! Number of images
-	int32_t nb;       
+	int32_t nb;
 
 	//! Time for each image
-    float *time;   
+    float *time;
 
 	//! Data of each image
-	uint8_t **data;  
+	uint8_t **data;
 } PACK_STRUCT;
 
 // -------------------------------------------------------------------------------------
@@ -498,10 +498,10 @@ struct TexCoord
 struct TexCoord_MDL3
 {
 	//! position, horizontally in range 0..skinwidth-1
-	int16_t u; 
+	int16_t u;
 
 	//! position, vertically in range 0..skinheight-1
-	int16_t v; 
+	int16_t v;
 } PACK_STRUCT;
 
 // -------------------------------------------------------------------------------------
@@ -511,10 +511,10 @@ struct TexCoord_MDL3
 struct TexCoord_MDL7
 {
 	//! position, horizontally in range 0..1
-	float u; 
+	float u;
 
 	//! position, vertically in range 0..1
-	float v; 
+	float v;
 } PACK_STRUCT;
 
 // -------------------------------------------------------------------------------------
@@ -527,10 +527,10 @@ struct TexCoord_MDL7
 struct SkinSet_MDL7
 {
 	//! Index into the UV coordinate list
-	uint16_t	st_index[3]; // size 6	
+	uint16_t	st_index[3]; // size 6
 
 	//! Material index
-	int32_t		material;	 // size 4				
+	int32_t		material;	 // size 4
 } PACK_STRUCT;
 
 // -------------------------------------------------------------------------------------
@@ -540,10 +540,10 @@ struct SkinSet_MDL7
 struct Triangle
 {
 	//! 0 = backface, 1 = frontface
-	int32_t facesfront;  
+	int32_t facesfront;
 
 	//! Vertex indices
-	int32_t vertex[3];   
+	int32_t vertex[3];
 } PACK_STRUCT;
 
 // -------------------------------------------------------------------------------------
@@ -556,7 +556,7 @@ struct Triangle_MDL3
 	uint16_t index_xyz[3];
 
 	//! Index of 3 skin vertices in range 0..numskinverts
-	uint16_t index_uv[3]; 
+	uint16_t index_uv[3];
 } PACK_STRUCT;
 
 // -------------------------------------------------------------------------------------
@@ -570,17 +570,17 @@ struct Triangle_MDL7
 
 	//! Two skinsets. The second will be used for multi-texturing
 	SkinSet_MDL7  skinsets[2];
-} PACK_STRUCT; 
+} PACK_STRUCT;
 
 #if (!defined AI_MDL7_TRIANGLE_STD_SIZE_ONE_UV)
 #	define AI_MDL7_TRIANGLE_STD_SIZE_ONE_UV (6+sizeof(SkinSet_MDL7)-sizeof(uint32_t))
-#endif 
+#endif
 #if (!defined AI_MDL7_TRIANGLE_STD_SIZE_ONE_UV_WITH_MATINDEX)
 #	define AI_MDL7_TRIANGLE_STD_SIZE_ONE_UV_WITH_MATINDEX (6+sizeof(SkinSet_MDL7))
-#endif 
+#endif
 #if (!defined AI_MDL7_TRIANGLE_STD_SIZE_TWO_UV)
 #	define AI_MDL7_TRIANGLE_STD_SIZE_TWO_UV (6+2*sizeof(SkinSet_MDL7))
-#endif 
+#endif
 
 // Helper constants for Triangle::facesfront
 #if (!defined AI_MDL_BACKFACE)
@@ -634,10 +634,10 @@ struct Vertex_MDL7
 struct BoneTransform_MDL7
 {
 	//! 4*3
-	float	m [4*4];				
+	float	m [4*4];
 
 	//! the index of this vertex, 0.. header::bones_num - 1
-	uint16_t bone_index;		
+	uint16_t bone_index;
 
 	//! I HATE 3DGS AND THE SILLY DEVELOPER WHO DESIGNED
 	//! THIS STUPID FILE FORMAT!
@@ -655,8 +655,8 @@ struct BoneTransform_MDL7
 struct Frame_MDL7
 {
 	char	frame_name[AI_MDL7_MAX_FRAMENAMESIZE];
-	uint32_t	vertices_count;			
+	uint32_t	vertices_count;
-	uint32_t	transmatrix_count;		
+	uint32_t	transmatrix_count;
 };
 
 
@@ -667,16 +667,16 @@ struct Frame_MDL7
 struct SimpleFrame
 {
 	//! Minimum vertex of the bounding box
-	Vertex bboxmin; 
+	Vertex bboxmin;
 
 	//! Maximum vertex of the bounding box
-	Vertex bboxmax; 
+	Vertex bboxmax;
 
 	//! Name of the frame
 	char name[16];
 
 	//! Vertex list of the frame
-	Vertex *verts; 
+	Vertex *verts;
 } PACK_STRUCT;
 
 // -------------------------------------------------------------------------------------
@@ -686,10 +686,10 @@ struct SimpleFrame
 struct Frame
 {
 	//! 0 = simple frame, !0 = group frame
-	int32_t type;       
+	int32_t type;
 
 	//! Frame data
-	SimpleFrame frame;  	      
+	SimpleFrame frame;
 } PACK_STRUCT;
 
 
@@ -697,16 +697,16 @@ struct Frame
 struct SimpleFrame_MDLn_SP
 {
 	//! Minimum vertex of the bounding box
-	Vertex_MDL4 bboxmin; 
+	Vertex_MDL4 bboxmin;
 
 	//! Maximum vertex of the bounding box
-	Vertex_MDL4 bboxmax; 
+	Vertex_MDL4 bboxmax;
 
 	//! Name of the frame
 	char name[16];
 
 	//! Vertex list of the frame
-	Vertex_MDL4 *verts; 
+	Vertex_MDL4 *verts;
 } PACK_STRUCT;
 
 // -------------------------------------------------------------------------------------
@@ -716,19 +716,19 @@ struct SimpleFrame_MDLn_SP
 struct GroupFrame
 {
 	//! 0 = simple frame, !0 = group frame
-	int32_t type;                         
+	int32_t type;
 
 	//! Minimum vertex for all single frames
-	Vertex min;         
+	Vertex min;
 
 	//! Maximum vertex for all single frames
-	Vertex max;         
+	Vertex max;
 
 	//! Time for all single frames
-	float *time;                  
+	float *time;
 
 	//! List of single frames
-	SimpleFrame *frames; 
+	SimpleFrame *frames;
 } PACK_STRUCT;
 
 #include "./../include/assimp/Compiler/poppack1.h"
@@ -752,7 +752,7 @@ struct IntFace_MDL7
 
 	//! Material index (maximally two channels, which are joined later)
 	unsigned int iMatIndex[2];
-}; 
+};
 
 // -------------------------------------------------------------------------------------
 /** \struct IntMaterial_MDL7
@@ -812,7 +812,7 @@ struct IntBone_MDL7 : aiBone
 struct IntFrameInfo_MDL7
 {
 	//! Construction from an existing frame header
-	IntFrameInfo_MDL7(BE_NCONST MDL::Frame_MDL7* _pcFrame,unsigned int _iIndex) 
+	IntFrameInfo_MDL7(BE_NCONST MDL::Frame_MDL7* _pcFrame,unsigned int _iIndex)
 		: iIndex(_iIndex)
 		, pcFrame(_pcFrame)
 	{}
@@ -821,7 +821,7 @@ struct IntFrameInfo_MDL7
 	unsigned int iIndex;
 
 	//! Points to the header of the frame
-	BE_NCONST MDL::Frame_MDL7*	pcFrame; 
+	BE_NCONST MDL::Frame_MDL7*	pcFrame;
 };
 
 // -------------------------------------------------------------------------------------
@@ -829,7 +829,7 @@ struct IntFrameInfo_MDL7
 struct IntGroupInfo_MDL7
 {
 	//! Default constructor
-	IntGroupInfo_MDL7()		
+	IntGroupInfo_MDL7()
 		:	iIndex(0)
 		,	pcGroup(NULL)
 		,	pcGroupUVs(NULL)
@@ -847,13 +847,13 @@ struct IntGroupInfo_MDL7
 	unsigned int iIndex;
 
 	//! Points to the header of the group
-	BE_NCONST MDL::Group_MDL7*		pcGroup; 
+	BE_NCONST MDL::Group_MDL7*		pcGroup;
 
 	//! Points to the beginning of the uv coordinate section
-	BE_NCONST MDL::TexCoord_MDL7*	pcGroupUVs;		
+	BE_NCONST MDL::TexCoord_MDL7*	pcGroupUVs;
 
 	//! Points to the beginning of the triangle section
-	MDL::Triangle_MDL7*	pcGroupTris;		
+	MDL::Triangle_MDL7*	pcGroupTris;
 
 	//! Points to the beginning of the vertex section
 	BE_NCONST MDL::Vertex_MDL7*		pcGroupVerts;
@@ -868,16 +868,16 @@ struct IntGroupData_MDL7
 	{}
 
 	//! Array of faces that belong to the group
-	MDL::IntFace_MDL7* pcFaces;		
+	MDL::IntFace_MDL7* pcFaces;
 
 	//! Array of vertex positions
-	std::vector<aiVector3D>		vPositions;			
+	std::vector<aiVector3D>		vPositions;
 
 	//! Array of vertex normals
-	std::vector<aiVector3D>		vNormals;	
+	std::vector<aiVector3D>		vNormals;
 
 	//! Array of bones indices
-	std::vector<unsigned int>	aiBones;	
+	std::vector<unsigned int>	aiBones;
 
 	//! First UV coordinate set
 	std::vector<aiVector3D>		vTextureCoords1;
@@ -895,7 +895,7 @@ struct IntGroupData_MDL7
 struct IntSharedData_MDL7
 {
 	//! Default constructor
-	IntSharedData_MDL7() 
+	IntSharedData_MDL7()
 	{
 		abNeedMaterials.reserve(10);
 	}
@@ -929,7 +929,7 @@ struct IntSharedData_MDL7
 //! Contains input data for GenerateOutputMeshes_3DGS_MDL7
 struct IntSplitGroupData_MDL7
 {
-	//! Construction from a given shared data set 
+	//! Construction from a given shared data set
 	IntSplitGroupData_MDL7(IntSharedData_MDL7& _shared,
 		std::vector<aiMesh*>& _avOutList)
 
@@ -955,7 +955,7 @@ struct IntSplitGroupData_MDL7
 	//! Shared data for all groups of the model
 	IntSharedData_MDL7& shared;
 
-	//! List of meshes 
+	//! List of meshes
 	std::vector<aiMesh*>& avOutList;
 };
 

code/ObjFileImporter.cpp

@@ -45,12 +45,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "DefaultIOSystem.h"
 #include "ObjFileImporter.h"
 #include "ObjFileParser.h"
-#include "ObjFileData.h"
+#include "ObjFileData.h"
-#include <boost/scoped_ptr.hpp>
+#include <boost/scoped_ptr.hpp>
-#include "../include/assimp/Importer.hpp"
+#include "../include/assimp/Importer.hpp"
-#include "../include/assimp/scene.h"
+#include "../include/assimp/scene.h"
-#include "../include/assimp/ai_assert.h"
+#include "../include/assimp/ai_assert.h"
-#include "../include/assimp/DefaultLogger.hpp"
+#include "../include/assimp/DefaultLogger.hpp"
 
 
 static const aiImporterDesc desc = {

code/ObjFileMtlImporter.cpp

@@ -42,13 +42,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER
 
+#include <stdlib.h>
 #include "ObjFileMtlImporter.h"
 #include "ObjTools.h"
 #include "ObjFileData.h"
 #include "fast_atof.h"
-#include "ParsingUtils.h"
+#include "ParsingUtils.h"
-#include "../include/assimp/material.h"
+#include "../include/assimp/material.h"
-#include "../include/assimp/DefaultLogger.hpp"
+#include "../include/assimp/DefaultLogger.hpp"
 
 
 namespace Assimp	{
@@ -85,147 +86,147 @@ static const std::string TypeOption			= "-type";
 // -------------------------------------------------------------------
 //	Constructor
 ObjFileMtlImporter::ObjFileMtlImporter( std::vector<char> &buffer, 
-									   const std::string & /*strAbsPath*/,
+                                       const std::string & /*strAbsPath*/,
-									   ObjFile::Model *pModel ) :
+                                       ObjFile::Model *pModel ) :
-	m_DataIt( buffer.begin() ),
+    m_DataIt( buffer.begin() ),
-	m_DataItEnd( buffer.end() ),
+    m_DataItEnd( buffer.end() ),
-	m_pModel( pModel ),
+    m_pModel( pModel ),
-	m_uiLine( 0 )
+    m_uiLine( 0 )
 {
-	ai_assert( NULL != m_pModel );
+    ai_assert( NULL != m_pModel );
-	if ( NULL == m_pModel->m_pDefaultMaterial )
+    if ( NULL == m_pModel->m_pDefaultMaterial )
-	{
+    {
-		m_pModel->m_pDefaultMaterial = new ObjFile::Material;
+        m_pModel->m_pDefaultMaterial = new ObjFile::Material;
-		m_pModel->m_pDefaultMaterial->MaterialName.Set( "default" );
+        m_pModel->m_pDefaultMaterial->MaterialName.Set( "default" );
-	}
+    }
-	load();
+    load();
 }
 
 // -------------------------------------------------------------------
 //	Destructor
 ObjFileMtlImporter::~ObjFileMtlImporter()
 {
-	// empty
+    // empty
 }
 
 // -------------------------------------------------------------------
 //	Private copy constructor
 ObjFileMtlImporter::ObjFileMtlImporter(const ObjFileMtlImporter & /* rOther */ )
 {
-	// empty
+    // empty
 }
-	
+    
 // -------------------------------------------------------------------
 //	Private copy constructor
 ObjFileMtlImporter &ObjFileMtlImporter::operator = ( const ObjFileMtlImporter & /*rOther */ )
 {
-	return *this;
+    return *this;
 }
 
 // -------------------------------------------------------------------
 //	Loads the material description
 void ObjFileMtlImporter::load()
 {
-	if ( m_DataIt == m_DataItEnd )
+    if ( m_DataIt == m_DataItEnd )
-		return;
+        return;
 
-	while ( m_DataIt != m_DataItEnd )
+    while ( m_DataIt != m_DataItEnd )
-	{
+    {
-		switch (*m_DataIt)
+        switch (*m_DataIt)
-		{
+        {
-		case 'k':
+        case 'k':
-		case 'K':
+        case 'K':
-			{
+            {
-				++m_DataIt;
+                ++m_DataIt;
-				if (*m_DataIt == 'a') // Ambient color
+                if (*m_DataIt == 'a') // Ambient color
-				{
+                {
-					++m_DataIt;
+                    ++m_DataIt;
-					getColorRGBA( &m_pModel->m_pCurrentMaterial->ambient );
+                    getColorRGBA( &m_pModel->m_pCurrentMaterial->ambient );
-				}
+                }
-				else if (*m_DataIt == 'd')	// Diffuse color
+                else if (*m_DataIt == 'd')	// Diffuse color
-				{
+                {
-					++m_DataIt;
+                    ++m_DataIt;
-					getColorRGBA( &m_pModel->m_pCurrentMaterial->diffuse );
+                    getColorRGBA( &m_pModel->m_pCurrentMaterial->diffuse );
-				}
+                }
-				else if (*m_DataIt == 's')
+                else if (*m_DataIt == 's')
-				{
+                {
-					++m_DataIt;
+                    ++m_DataIt;
-					getColorRGBA( &m_pModel->m_pCurrentMaterial->specular );
+                    getColorRGBA( &m_pModel->m_pCurrentMaterial->specular );
-				}
+                }
-				else if (*m_DataIt == 'e')
+                else if (*m_DataIt == 'e')
-				{
+                {
-					++m_DataIt;
+                    ++m_DataIt;
-					getColorRGBA( &m_pModel->m_pCurrentMaterial->emissive );
+                    getColorRGBA( &m_pModel->m_pCurrentMaterial->emissive );
-				}
+                }
-				m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
+                m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-			}
+            }
-			break;
+            break;
 
-		case 'd':	// Alpha value
+        case 'd':	// Alpha value
-			{
+            {
-				++m_DataIt;
+                ++m_DataIt;
-				getFloatValue( m_pModel->m_pCurrentMaterial->alpha );
+                getFloatValue( m_pModel->m_pCurrentMaterial->alpha );
-				m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
+                m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-			}
+            }
-			break;
+            break;
 
-		case 'N':
+        case 'N':
-		case 'n':
+        case 'n':
-			{
+            {
-				++m_DataIt;
+                ++m_DataIt;
-				switch(*m_DataIt)
+                switch(*m_DataIt)
-				{
+                {
-				case 's':	// Specular exponent
+                case 's':	// Specular exponent
-					++m_DataIt;
+                    ++m_DataIt;
-					getFloatValue(m_pModel->m_pCurrentMaterial->shineness);
+                    getFloatValue(m_pModel->m_pCurrentMaterial->shineness);
-					break;
+                    break;
-				case 'i':	// Index Of refraction
+                case 'i':	// Index Of refraction
-					++m_DataIt;
+                    ++m_DataIt;
-					getFloatValue(m_pModel->m_pCurrentMaterial->ior);
+                    getFloatValue(m_pModel->m_pCurrentMaterial->ior);
-					break;
+                    break;
-				case 'e':	// New material
+                case 'e':	// New material
-					createMaterial();
+                    createMaterial();
-					break;
+                    break;
-				}
+                }
-				m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
+                m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-			}
+            }
-			break;
+            break;
 
-		case 'm':	// Texture
+        case 'm':	// Texture
-		case 'b':   // quick'n'dirty - for 'bump' sections
+        case 'b':   // quick'n'dirty - for 'bump' sections
-			{
+            {
-				getTexture();
+                getTexture();
-				m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
+                m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-			}
+            }
-			break;
+            break;
 
-		case 'i':	// Illumination model
+        case 'i':	// Illumination model
-			{
+            {
-				m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+                m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
-				getIlluminationModel( m_pModel->m_pCurrentMaterial->illumination_model );
+                getIlluminationModel( m_pModel->m_pCurrentMaterial->illumination_model );
-				m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
+                m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-			}
+            }
-			break;
+            break;
 
-		default:
+        default:
-			{
+            {
-				m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
+                m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
-			}
+            }
-			break;
+            break;
-		}
+        }
-	}
+    }
 }
 
 // -------------------------------------------------------------------
 //	Loads a color definition
 void ObjFileMtlImporter::getColorRGBA( aiColor3D *pColor )
 {
-	ai_assert( NULL != pColor );
+    ai_assert( NULL != pColor );
-	
+    
-	float r( 0.0f ), g( 0.0f ), b( 0.0f );
+    float r( 0.0f ), g( 0.0f ), b( 0.0f );
-	m_DataIt = getFloat<DataArrayIt>( m_DataIt, m_DataItEnd, r );
+    m_DataIt = getFloat<DataArrayIt>( m_DataIt, m_DataItEnd, r );
-	pColor->r = r;
+    pColor->r = r;
-	
+    
     // we have to check if color is default 0 with only one token
     if( !IsLineEnd( *m_DataIt ) ) {
         m_DataIt = getFloat<DataArrayIt>( m_DataIt, m_DataItEnd, g );
@@ -239,107 +240,107 @@ void ObjFileMtlImporter::getColorRGBA( aiColor3D *pColor )
 //	Loads the kind of illumination model.
 void ObjFileMtlImporter::getIlluminationModel( int &illum_model )
 {
-	m_DataIt = CopyNextWord<DataArrayIt>( m_DataIt, m_DataItEnd, m_buffer, BUFFERSIZE );
+    m_DataIt = CopyNextWord<DataArrayIt>( m_DataIt, m_DataItEnd, m_buffer, BUFFERSIZE );
-	illum_model = atoi(m_buffer);
+    illum_model = atoi(m_buffer);
 }
 
 // -------------------------------------------------------------------
 //	Loads a single float value. 
 void ObjFileMtlImporter::getFloatValue( float &value )
 {
-	m_DataIt = CopyNextWord<DataArrayIt>( m_DataIt, m_DataItEnd, m_buffer, BUFFERSIZE );
+    m_DataIt = CopyNextWord<DataArrayIt>( m_DataIt, m_DataItEnd, m_buffer, BUFFERSIZE );
-	value = (float) fast_atof(m_buffer);
+    value = (float) fast_atof(m_buffer);
 }
 
 // -------------------------------------------------------------------
 //	Creates a material from loaded data.
 void ObjFileMtlImporter::createMaterial()
 {	
-	std::string line( "" );
+    std::string line( "" );
     while( !IsLineEnd( *m_DataIt ) ) {
-		line += *m_DataIt;
+        line += *m_DataIt;
-		++m_DataIt;
+        ++m_DataIt;
-	}
+    }
-	
+    
-	std::vector<std::string> token;
+    std::vector<std::string> token;
-	const unsigned int numToken = tokenize<std::string>( line, token, " " );
+    const unsigned int numToken = tokenize<std::string>( line, token, " " );
-	std::string name( "" );
+    std::string name( "" );
-	if ( numToken == 1 ) {
+    if ( numToken == 1 ) {
-		name = AI_DEFAULT_MATERIAL_NAME;
+        name = AI_DEFAULT_MATERIAL_NAME;
-	} else {
+    } else {
-		name = token[ 1 ];
+        name = token[ 1 ];
-	}
+    }
 
-	std::map<std::string, ObjFile::Material*>::iterator it = m_pModel->m_MaterialMap.find( name );
+    std::map<std::string, ObjFile::Material*>::iterator it = m_pModel->m_MaterialMap.find( name );
-	if ( m_pModel->m_MaterialMap.end() == it) {
+    if ( m_pModel->m_MaterialMap.end() == it) {
-		// New Material created
+        // New Material created
-		m_pModel->m_pCurrentMaterial = new ObjFile::Material();	
+        m_pModel->m_pCurrentMaterial = new ObjFile::Material();	
-		m_pModel->m_pCurrentMaterial->MaterialName.Set( name );
+        m_pModel->m_pCurrentMaterial->MaterialName.Set( name );
-		m_pModel->m_MaterialLib.push_back( name );
+        m_pModel->m_MaterialLib.push_back( name );
-		m_pModel->m_MaterialMap[ name ] = m_pModel->m_pCurrentMaterial;
+        m_pModel->m_MaterialMap[ name ] = m_pModel->m_pCurrentMaterial;
-	} else {
+    } else {
-		// Use older material
+        // Use older material
-		m_pModel->m_pCurrentMaterial = (*it).second;
+        m_pModel->m_pCurrentMaterial = (*it).second;
-	}
+    }
 }
 
 // -------------------------------------------------------------------
 //	Gets a texture name from data.
 void ObjFileMtlImporter::getTexture() {
-	aiString *out( NULL );
+    aiString *out( NULL );
-	int clampIndex = -1;
+    int clampIndex = -1;
 
-	const char *pPtr( &(*m_DataIt) );
+    const char *pPtr( &(*m_DataIt) );
-	if ( !ASSIMP_strincmp( pPtr, DiffuseTexture.c_str(), DiffuseTexture.size() ) ) {
+    if ( !ASSIMP_strincmp( pPtr, DiffuseTexture.c_str(), DiffuseTexture.size() ) ) {
-		// Diffuse texture
+        // Diffuse texture
-		out = & m_pModel->m_pCurrentMaterial->texture;
+        out = & m_pModel->m_pCurrentMaterial->texture;
-		clampIndex = ObjFile::Material::TextureDiffuseType;
+        clampIndex = ObjFile::Material::TextureDiffuseType;
-	} else if ( !ASSIMP_strincmp( pPtr,AmbientTexture.c_str(),AmbientTexture.size() ) ) {
+    } else if ( !ASSIMP_strincmp( pPtr,AmbientTexture.c_str(),AmbientTexture.size() ) ) {
-		// Ambient texture
+        // Ambient texture
-		out = & m_pModel->m_pCurrentMaterial->textureAmbient;
+        out = & m_pModel->m_pCurrentMaterial->textureAmbient;
-		clampIndex = ObjFile::Material::TextureAmbientType;
+        clampIndex = ObjFile::Material::TextureAmbientType;
-	} else if (!ASSIMP_strincmp( pPtr, SpecularTexture.c_str(), SpecularTexture.size())) {
+    } else if (!ASSIMP_strincmp( pPtr, SpecularTexture.c_str(), SpecularTexture.size())) {
-		// Specular texture
+        // Specular texture
-		out = & m_pModel->m_pCurrentMaterial->textureSpecular;
+        out = & m_pModel->m_pCurrentMaterial->textureSpecular;
-		clampIndex = ObjFile::Material::TextureSpecularType;
+        clampIndex = ObjFile::Material::TextureSpecularType;
-	} else if ( !ASSIMP_strincmp( pPtr, OpacityTexture.c_str(), OpacityTexture.size() ) ) {
+    } else if ( !ASSIMP_strincmp( pPtr, OpacityTexture.c_str(), OpacityTexture.size() ) ) {
-		// Opacity texture
+        // Opacity texture
-		out = & m_pModel->m_pCurrentMaterial->textureOpacity;
+        out = & m_pModel->m_pCurrentMaterial->textureOpacity;
-		clampIndex = ObjFile::Material::TextureOpacityType;
+        clampIndex = ObjFile::Material::TextureOpacityType;
-	} else if (!ASSIMP_strincmp( pPtr, EmmissiveTexture.c_str(), EmmissiveTexture.size())) {
+    } else if (!ASSIMP_strincmp( pPtr, EmmissiveTexture.c_str(), EmmissiveTexture.size())) {
-		// Emissive texture
+        // Emissive texture
-		out = & m_pModel->m_pCurrentMaterial->textureEmissive;
+        out = & m_pModel->m_pCurrentMaterial->textureEmissive;
-		clampIndex = ObjFile::Material::TextureEmissiveType;
+        clampIndex = ObjFile::Material::TextureEmissiveType;
-	} else if ( !ASSIMP_strincmp( pPtr, BumpTexture1.c_str(), BumpTexture1.size() ) ||
+    } else if ( !ASSIMP_strincmp( pPtr, BumpTexture1.c_str(), BumpTexture1.size() ) ||
-		        !ASSIMP_strincmp( pPtr, BumpTexture2.c_str(), BumpTexture2.size() ) || 
+                !ASSIMP_strincmp( pPtr, BumpTexture2.c_str(), BumpTexture2.size() ) || 
-		        !ASSIMP_strincmp( pPtr, BumpTexture3.c_str(), BumpTexture3.size() ) ) {
+                !ASSIMP_strincmp( pPtr, BumpTexture3.c_str(), BumpTexture3.size() ) ) {
-		// Bump texture 
+        // Bump texture 
-		out = & m_pModel->m_pCurrentMaterial->textureBump;
+        out = & m_pModel->m_pCurrentMaterial->textureBump;
-		clampIndex = ObjFile::Material::TextureBumpType;
+        clampIndex = ObjFile::Material::TextureBumpType;
-	} else if (!ASSIMP_strincmp( pPtr,NormalTexture.c_str(), NormalTexture.size())) { 
+    } else if (!ASSIMP_strincmp( pPtr,NormalTexture.c_str(), NormalTexture.size())) { 
-		// Normal map
+        // Normal map
-		out = & m_pModel->m_pCurrentMaterial->textureNormal;
+        out = & m_pModel->m_pCurrentMaterial->textureNormal;
-		clampIndex = ObjFile::Material::TextureNormalType;
+        clampIndex = ObjFile::Material::TextureNormalType;
-	} else if (!ASSIMP_strincmp( pPtr, DisplacementTexture.c_str(), DisplacementTexture.size() ) ) {
+    } else if (!ASSIMP_strincmp( pPtr, DisplacementTexture.c_str(), DisplacementTexture.size() ) ) {
-		// Displacement texture
+        // Displacement texture
-		out = &m_pModel->m_pCurrentMaterial->textureDisp;
+        out = &m_pModel->m_pCurrentMaterial->textureDisp;
-		clampIndex = ObjFile::Material::TextureDispType;
+        clampIndex = ObjFile::Material::TextureDispType;
-	} else if (!ASSIMP_strincmp( pPtr, SpecularityTexture.c_str(),SpecularityTexture.size() ) ) {
+    } else if (!ASSIMP_strincmp( pPtr, SpecularityTexture.c_str(),SpecularityTexture.size() ) ) {
-		// Specularity scaling (glossiness)
+        // Specularity scaling (glossiness)
-		out = & m_pModel->m_pCurrentMaterial->textureSpecularity;
+        out = & m_pModel->m_pCurrentMaterial->textureSpecularity;
-		clampIndex = ObjFile::Material::TextureSpecularityType;
+        clampIndex = ObjFile::Material::TextureSpecularityType;
-	} else {
+    } else {
-		DefaultLogger::get()->error("OBJ/MTL: Encountered unknown texture type");
+        DefaultLogger::get()->error("OBJ/MTL: Encountered unknown texture type");
-		return;
+        return;
-	}
+    }
 
-	bool clamp = false;
+    bool clamp = false;
-	getTextureOption(clamp);
+    getTextureOption(clamp);
-	m_pModel->m_pCurrentMaterial->clamp[clampIndex] = clamp;
+    m_pModel->m_pCurrentMaterial->clamp[clampIndex] = clamp;
 
-	std::string strTexture;
+    std::string strTexture;
-	m_DataIt = getName<DataArrayIt>( m_DataIt, m_DataItEnd, strTexture );
+    m_DataIt = getName<DataArrayIt>( m_DataIt, m_DataItEnd, strTexture );
-	out->Set( strTexture );
+    out->Set( strTexture );
 }
 
 /* /////////////////////////////////////////////////////////////////////////////
@@ -359,54 +360,54 @@ void ObjFileMtlImporter::getTexture() {
  */
 void ObjFileMtlImporter::getTextureOption(bool &clamp)
 {
-	m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+    m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
 
-	//If there is any more texture option
+    //If there is any more texture option
-	while (!isEndOfBuffer(m_DataIt, m_DataItEnd) && *m_DataIt == '-')
+    while (!isEndOfBuffer(m_DataIt, m_DataItEnd) && *m_DataIt == '-')
-	{
+    {
-		const char *pPtr( &(*m_DataIt) );
+        const char *pPtr( &(*m_DataIt) );
-		//skip option key and value
+        //skip option key and value
-		int skipToken = 1;
+        int skipToken = 1;
 
-		if (!ASSIMP_strincmp(pPtr, ClampOption.c_str(), ClampOption.size()))
+        if (!ASSIMP_strincmp(pPtr, ClampOption.c_str(), ClampOption.size()))
-		{
+        {
-			DataArrayIt it = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+            DataArrayIt it = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
-			char value[3];
+            char value[3];
-			CopyNextWord(it, m_DataItEnd, value, sizeof(value) / sizeof(*value));
+            CopyNextWord(it, m_DataItEnd, value, sizeof(value) / sizeof(*value));
-			if (!ASSIMP_strincmp(value, "on", 2))
+            if (!ASSIMP_strincmp(value, "on", 2))
-			{
+            {
-				clamp = true;
+                clamp = true;
-			}
+            }
 
-			skipToken = 2;
+            skipToken = 2;
-		}
+        }
-		else if (  !ASSIMP_strincmp(pPtr, BlendUOption.c_str(), BlendUOption.size())
+        else if (  !ASSIMP_strincmp(pPtr, BlendUOption.c_str(), BlendUOption.size())
-				|| !ASSIMP_strincmp(pPtr, BlendVOption.c_str(), BlendVOption.size())
+                || !ASSIMP_strincmp(pPtr, BlendVOption.c_str(), BlendVOption.size())
-				|| !ASSIMP_strincmp(pPtr, BoostOption.c_str(), BoostOption.size())
+                || !ASSIMP_strincmp(pPtr, BoostOption.c_str(), BoostOption.size())
-				|| !ASSIMP_strincmp(pPtr, ResolutionOption.c_str(), ResolutionOption.size())
+                || !ASSIMP_strincmp(pPtr, ResolutionOption.c_str(), ResolutionOption.size())
-				|| !ASSIMP_strincmp(pPtr, BumpOption.c_str(), BumpOption.size())
+                || !ASSIMP_strincmp(pPtr, BumpOption.c_str(), BumpOption.size())
-				|| !ASSIMP_strincmp(pPtr, ChannelOption.c_str(), ChannelOption.size())
+                || !ASSIMP_strincmp(pPtr, ChannelOption.c_str(), ChannelOption.size())
-				|| !ASSIMP_strincmp(pPtr, TypeOption.c_str(), TypeOption.size()) )
+                || !ASSIMP_strincmp(pPtr, TypeOption.c_str(), TypeOption.size()) )
-		{
+        {
-			skipToken = 2;
+            skipToken = 2;
-		}
+        }
-		else if (!ASSIMP_strincmp(pPtr, ModifyMapOption.c_str(), ModifyMapOption.size()))
+        else if (!ASSIMP_strincmp(pPtr, ModifyMapOption.c_str(), ModifyMapOption.size()))
-		{
+        {
-			skipToken = 3;
+            skipToken = 3;
-		}
+        }
-		else if (  !ASSIMP_strincmp(pPtr, OffsetOption.c_str(), OffsetOption.size())
+        else if (  !ASSIMP_strincmp(pPtr, OffsetOption.c_str(), OffsetOption.size())
-				|| !ASSIMP_strincmp(pPtr, ScaleOption.c_str(), ScaleOption.size())
+                || !ASSIMP_strincmp(pPtr, ScaleOption.c_str(), ScaleOption.size())
-				|| !ASSIMP_strincmp(pPtr, TurbulenceOption.c_str(), TurbulenceOption.size())
+                || !ASSIMP_strincmp(pPtr, TurbulenceOption.c_str(), TurbulenceOption.size())
-				)
+                )
-		{
+        {
-			skipToken = 4;
+            skipToken = 4;
-		}
+        }
 
-		for (int i = 0; i < skipToken; ++i)
+        for (int i = 0; i < skipToken; ++i)
-		{
+        {
-			m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
+            m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
-		}
+        }
-	}
+    }
 }
 
 // -------------------------------------------------------------------

code/ObjFileParser.cpp

@@ -53,6 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../include/assimp/DefaultLogger.hpp"
 #include "../include/assimp/material.h"
 #include "../include/assimp/Importer.hpp"
+#include <cstdlib>
 
 
 namespace Assimp {

code/OpenGEXImporter.cpp

@@ -44,8 +44,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "MakeVerboseFormat.h"
 
 #include <openddlparser/OpenDDLParser.h>
-#include "../include/assimp/scene.h"
+#include <assimp/scene.h>
-
+#include <assimp/ai_assert.h>
 
 #include <vector>
 
@@ -80,6 +80,10 @@ namespace Grammar {
     static const char *IndexArrayType      = "IndexArray";
     static const char *MaterialType        = "Material";
     static const char *ColorType           = "Color";
+    static const std::string DiffuseColorToken = "diffuse";
+    static const std::string SpecularColorToken = "specular";
+    static const std::string EmissionColorToken = "emission";
+
     static const char *TextureType         = "Texture";
 
     enum TokenType {
@@ -363,9 +367,9 @@ void OpenGEXImporter::handleMetricNode( DDLNode *node, aiScene *pScene ) {
 
     Property *prop( node->getProperties() );
     while( NULL != prop ) {
-        if( NULL != prop->m_id ) {
+        if( NULL != prop->m_key ) {
-            if( Value::ddl_string == prop->m_primData->m_type ) {
+            if( Value::ddl_string == prop->m_value->m_type ) {
-                std::string valName( (char*) prop->m_primData->m_data );
+                std::string valName( ( char* ) prop->m_value->m_data );
                 int type( Grammar::isValidMetricType( valName.c_str() ) );
                 if( Grammar::NoneType != type ) {
                     Value *val( node->getValue() );
@@ -415,7 +419,7 @@ static void getRefNames( DDLNode *node, std::vector<std::string> &names ) {
         for( size_t i = 0; i < ref->m_numRefs; i++ )  {
             Name *currentName( ref->m_referencedName[ i ] );
             if( NULL != currentName && NULL != currentName->m_id ) {
-                const std::string name( currentName->m_id->m_buffer );
+                const std::string name( currentName->m_id->m_text.m_buffer );
                 if( !name.empty() ) {
                     names.push_back( name );
                 }
@@ -530,10 +534,10 @@ static void propId2StdString( Property *prop, std::string &name, std::string &ke
         return;
     }
 
-    if( NULL != prop->m_id ) {
+    if( NULL != prop->m_key ) {
-        name = prop->m_id->m_buffer;
+        name = prop->m_key->m_text.m_buffer;
-        if( Value::ddl_string == prop->m_primData->m_type ) {
+        if( Value::ddl_string == prop->m_value->m_type ) {
-            key = prop->m_primData->getString();
+            key = prop->m_value->getString();
         }
     }
 }
@@ -705,7 +709,7 @@ void OpenGEXImporter::handleIndexArrayNode( ODDLParser::DDLNode *node, aiScene *
         Value *next( vaList->m_dataList );
         for( size_t indices = 0; indices < current.mNumIndices; indices++ ) {
             const int idx = next->getInt32();
-            ai_assert( idx <= m_currentVertices.m_numVerts );
+            ai_assert( static_cast<size_t>( idx ) <= m_currentVertices.m_numVerts );
 
             aiVector3D &pos = ( m_currentVertices.m_vertices[ idx ] );
             aiVector3D &normal = ( m_currentVertices.m_normals[ idx ] );
@@ -725,30 +729,36 @@ void OpenGEXImporter::handleIndexArrayNode( ODDLParser::DDLNode *node, aiScene *
 }
 
 //------------------------------------------------------------------------------------------------
-static void getColorRGBA( aiColor3D *pColor, Value *data ) {
+static void getColorRGB( aiColor3D *pColor, DataArrayList *colList ) {
-    if( NULL == pColor || NULL == data ) {
+    if( NULL == pColor || NULL == colList ) {
         return;
     }
-
+    
-    pColor->r = data->getFloat();
+    ai_assert( 3 == colList->m_numItems );
-    data = data->getNext();
+    Value *val( colList->m_dataList );
-    pColor->g = data->getFloat();
+    pColor->r = val->getFloat();
-    data = data->getNext();
+    val = val->getNext();
-    pColor->b = data->getFloat();
+    pColor->g = val->getFloat();
-    data = data->getNext();
+    val = val->getNext();
+    pColor->b = val->getFloat();
 }
 
 //------------------------------------------------------------------------------------------------
 enum ColorType {
     NoneColor = 0,
-    DiffuseColor
+    DiffuseColor,
+    SpecularColor,
+    EmissionColor
 };
 
 //------------------------------------------------------------------------------------------------
 static ColorType getColorType( Identifier *id ) {
-    const int res(strncmp("diffuse", id->m_buffer, id->m_len ) );
+    if( id->m_text == Grammar::DiffuseColorToken ) {
-    if( 0 == res ) {
         return DiffuseColor;
+    } else if( id->m_text == Grammar::SpecularColorToken ) {
+        return SpecularColor;
+    } else if( id->m_text == Grammar::EmissionColorToken ) {
+        return EmissionColor;
     }
 
     return NoneColor;
@@ -769,9 +779,23 @@ void OpenGEXImporter::handleColorNode( ODDLParser::DDLNode *node, aiScene *pScen
         return;
     }
 
-    Property *colorProp = node->getProperties();
+    Property *prop = node->findPropertyByName( "attrib" );
-    if( NULL != colorProp ) {
+    if( NULL != prop ) {
-        if( NULL != colorProp->m_id ) {
+        if( NULL != prop->m_value ) {
+            DataArrayList *colList( node->getDataArrayList() );
+            if( NULL == colList ) {
+                return;
+            }
+            aiColor3D col;
+            getColorRGB( &col, colList );
+            const ColorType colType( getColorType( prop->m_key ) );
+            if( DiffuseColor == colType ) {
+                m_currentMaterial->AddProperty( &col, 1, AI_MATKEY_COLOR_DIFFUSE );
+            } else if( SpecularColor == colType ) {
+                m_currentMaterial->AddProperty( &col, 1, AI_MATKEY_COLOR_SPECULAR );
+            } else if( EmissionColor == colType ) {
+                m_currentMaterial->AddProperty( &col, 1, AI_MATKEY_COLOR_EMISSIVE );
+            }
         }
     }
 }
@@ -786,13 +810,10 @@ void OpenGEXImporter::copyMeshes( aiScene *pScene ) {
     if( m_meshCache.empty() ) {
         return;
     }
+    
     pScene->mNumMeshes = m_meshCache.size();
     pScene->mMeshes = new aiMesh*[ pScene->mNumMeshes ];
-    size_t i( 0 );
+    std::copy( m_meshCache.begin(), m_meshCache.end(), pScene->mMeshes );
-    for( std::vector<aiMesh*>::iterator it = m_meshCache.begin(); it != m_meshCache.end(); it++ ) {
-        pScene->mMeshes[ i ] = *it;
-        i++;
-    }
 }
 
 //------------------------------------------------------------------------------------------------
@@ -833,13 +854,10 @@ void OpenGEXImporter::createNodeTree( aiScene *pScene ) {
     if( m_root->m_children.empty() ) {
         return;
     }
-    size_t i( 0 );
+
     pScene->mRootNode->mNumChildren = m_root->m_children.size();
-    pScene->mRootNode->mChildren = new C_STRUCT aiNode*[ pScene->mRootNode->mNumChildren ];
+    pScene->mRootNode->mChildren = new aiNode*[ pScene->mRootNode->mNumChildren ];
-    for( ChildInfo::NodeList::iterator it = m_root->m_children.begin(); it != m_root->m_children.end(); it++ ) {
+    std::copy( m_root->m_children.begin(), m_root->m_children.end(), pScene->mRootNode->mChildren );
-        pScene->mRootNode->mChildren[ i ] = *it;
-        i++;
-    }
 }
 
 //------------------------------------------------------------------------------------------------

code/OpenGEXImporter.h

@@ -43,7 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_OPENGEX_IMPORTER
 
 #include "BaseImporter.h"
-#include "../include/assimp/mesh.h"
+#include <assimp/mesh.h>
 
 #include <vector>
 #include <list>

code/PlyExporter.cpp

@@ -44,11 +44,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "PlyExporter.h"
 #include <boost/scoped_ptr.hpp>
+#include <cmath>
 #include "Exceptional.h"
 #include "../include/assimp/scene.h"
 #include "../include/assimp/version.h"
 #include "../include/assimp/IOSystem.hpp"
-#include "../include/assimp/Exporter.hpp"
+#include "../include/assimp/Exporter.hpp"
+#include "qnan.h"
 
 
 using namespace Assimp;
@@ -213,6 +215,8 @@ PlyExporter::PlyExporter(const char* _filename, const aiScene* pScene, bool bina
 // ------------------------------------------------------------------------------------------------
 void PlyExporter::WriteMeshVerts(const aiMesh* m, unsigned int components)
 {
+	static const float inf = std::numeric_limits<float>::infinity();
+	
 	// If a component (for instance normal vectors) is present in at least one mesh in the scene,
 	// then default values are written for meshes that do not contain this component.
 	for (unsigned int i = 0; i < m->mNumVertices; ++i) {
@@ -222,11 +226,11 @@ void PlyExporter::WriteMeshVerts(const aiMesh* m, unsigned int components)
 			m->mVertices[i].z
 		;
 		if(components & PLY_EXPORT_HAS_NORMALS) {
-			if (m->HasNormals()) {
+			if (m->HasNormals() && is_not_qnan(m->mNormals[i].x) && std::fabs(m->mNormals[i].x) != inf) {
 				mOutput << 
-				" " << m->mNormals[i].x << 
+					" " << m->mNormals[i].x << 
-				" " << m->mNormals[i].y << 
+					" " << m->mNormals[i].y << 
-				" " << m->mNormals[i].z;
+					" " << m->mNormals[i].z;
 			}
 			else {
 				mOutput << " 0.0 0.0 0.0"; 

code/PlyParser.cpp

@@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "PlyLoader.h"
 #include "fast_atof.h"
 #include "../include/assimp/DefaultLogger.hpp"
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 
 
 using namespace Assimp;

code/Q3BSPZipArchive.cpp

@@ -45,6 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "Q3BSPZipArchive.h"
 #include <algorithm>
 #include <cassert>
+#include <cstdlib>
 #include "../include/assimp/ai_assert.h"
 
 
@@ -140,11 +141,11 @@ zlib_filefunc_def IOSystem2Unzip::get(IOSystem* pIOHandler) {
 ZipFile::ZipFile(size_t size) : m_Size(size) {
 	ai_assert(m_Size != 0);
 
-	m_Buffer = std::malloc(m_Size);
+	m_Buffer = malloc(m_Size);
 }
 	
 ZipFile::~ZipFile() {
-	std::free(m_Buffer);
+	free(m_Buffer);
 	m_Buffer = NULL;
 }
 

code/STEPFileEncoding.cpp

@@ -332,7 +332,7 @@ bool STEP::StringToUTF8(std::string& s)
 				case '4':
 					if (s[i+3] == '\\') {
 						const size_t basei = i+4;
-						size_t j = basei, jend = s.size()-4;						
+						size_t j = basei, jend = s.size()-3;				
 
 						for (; j < jend; ++j) {
 							if (s[j] == '\\' && s[j] == 'X' && s[j] == '0' && s[j] == '\\') {

code/STLExporter.cpp

@@ -49,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../include/assimp/Exporter.hpp"
 #include <boost/scoped_ptr.hpp>
 #include "Exceptional.h"
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 
 using namespace Assimp;
 namespace Assimp	{

code/SceneCombiner.cpp

@@ -920,7 +920,7 @@ void SceneCombiner::MergeMaterials(aiMaterial** dest,
 
 			// Test if we already have a matching property 
 			const aiMaterialProperty* prop_exist;
-			if(aiGetMaterialProperty(out, sprop->mKey.C_Str(), sprop->mType, sprop->mIndex, &prop_exist) != AI_SUCCESS) {
+			if(aiGetMaterialProperty(out, sprop->mKey.C_Str(), sprop->mSemantic, sprop->mIndex, &prop_exist) != AI_SUCCESS) {
 				// If not, we add it to the new material
 				aiMaterialProperty* prop = out->mProperties[out->mNumProperties] = new aiMaterialProperty();
 

code/StreamReader.h

@@ -7,8 +7,8 @@ Copyright (c) 2006-2012, assimp team
 
 All rights reserved.
 
-Redistribution and use of this software in source and binary forms, 
+Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following 
+with or without modification, are permitted provided that the following
 conditions are met:
 
 * Redistributions of source code must retain the above
@@ -25,16 +25,16 @@ conditions are met:
   derived from this software without specific prior
   written permission of the assimp team.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+"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 
+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 
+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 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
@@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_STREAMREADER_H_INCLUDED
 #define AI_STREAMREADER_H_INCLUDED
 
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 #include "Exceptional.h"
 #include <boost/shared_ptr.hpp>
 #include "../include/assimp/IOStream.hpp"
@@ -54,12 +54,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 
 // --------------------------------------------------------------------------------------------
-/** Wrapper class around IOStream to allow for consistent reading of binary data in both 
+/** Wrapper class around IOStream to allow for consistent reading of binary data in both
- *  little and big endian format. Don't attempt to instance the template directly. Use 
+ *  little and big endian format. Don't attempt to instance the template directly. Use
- *  StreamReaderLE to read from a little-endian stream and StreamReaderBE to read from a 
+ *  StreamReaderLE to read from a little-endian stream and StreamReaderBE to read from a
- *  BE stream. The class expects that the endianess of any input data is known at 
+ *  BE stream. The class expects that the endianess of any input data is known at
  *  compile-time, which should usually be true (#BaseImporter::ConvertToUTF8 implements
- *  runtime endianess conversions for text files). 
+ *  runtime endianess conversions for text files).
  *
  *  XXX switch from unsigned int for size types to size_t? or ptrdiff_t?*/
 // --------------------------------------------------------------------------------------------
@@ -71,7 +71,7 @@ public:
 
 	// FIXME: use these data types throughout the whole library,
 	// then change them to 64 bit values :-)
-	
+
 	typedef int diff;
 	typedef unsigned int pos;
 
@@ -80,7 +80,7 @@ public:
 
 	// ---------------------------------------------------------------------
 	/** Construction from a given stream with a well-defined endianess.
-	 * 
+	 *
 	 *  The StreamReader holds a permanent strong reference to the
 	 *  stream, which is released upon destruction.
 	 *  @param stream Input stream. The stream is not restarted if
@@ -94,7 +94,7 @@ public:
 		: stream(stream)
 		, le(le)
 	{
-		ai_assert(stream); 
+		ai_assert(stream);
 		InternBegin();
 	}
 
@@ -213,8 +213,8 @@ public:
 
 	// ---------------------------------------------------------------------
 	/** Set current file pointer (Get it from #GetPtr). This is if you
-	 *  prefer to do pointer arithmetics on your own or want to copy 
+	 *  prefer to do pointer arithmetics on your own or want to copy
-	 *  large chunks of data at once. 
+	 *  large chunks of data at once.
 	 *  @param p The new pointer, which is validated against the size
 	 *    limit and buffer boundaries. */
 	void SetPtr(int8_t* p)	{
@@ -250,7 +250,7 @@ public:
 
 	// ---------------------------------------------------------------------
 	/** Setup a temporary read limit
-	 * 
+	 *
 	 *  @param limit Maximum number of bytes to be read from
 	 *    the beginning of the file. Specifying UINT_MAX
 	 *    resets the limit to the original end of the stream. */
@@ -285,7 +285,7 @@ public:
 	/** overload operator>> and allow chaining of >> ops. */
 	template <typename T>
 	StreamReader& operator >> (T& f) {
-		f = Get<T>(); 
+		f = Get<T>();
 		return *this;
 	}
 
@@ -304,7 +304,7 @@ private:
 		memcpy (&f, current, sizeof(T));
 #else
 		T f = *((const T*)current);
-#endif	
+#endif
 		Intern :: Getter<SwapEndianess,T,RuntimeSwitch>() (&f,le);
 
 		current += sizeof(T);

code/StreamWriter.h

@@ -7,8 +7,8 @@ Copyright (c) 2006-2012, assimp team
 
 All rights reserved.
 
-Redistribution and use of this software in source and binary forms, 
+Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following 
+with or without modification, are permitted provided that the following
 conditions are met:
 
 * Redistributions of source code must retain the above
@@ -25,16 +25,16 @@ conditions are met:
   derived from this software without specific prior
   written permission of the assimp team.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+"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 
+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 
+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 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
@@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_STREAMWRITER_H_INCLUDED
 #define AI_STREAMWRITER_H_INCLUDED
 
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 #include "../include/assimp/IOStream.hpp"
 
 #include <boost/shared_ptr.hpp>
@@ -54,9 +54,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 
 // --------------------------------------------------------------------------------------------
-/** Wrapper class around IOStream to allow for consistent writing of binary data in both 
+/** Wrapper class around IOStream to allow for consistent writing of binary data in both
- *  little and big endian format. Don't attempt to instance the template directly. Use 
+ *  little and big endian format. Don't attempt to instance the template directly. Use
- *  StreamWriterLE to read from a little-endian stream and StreamWriterBE to read from a 
+ *  StreamWriterLE to read from a little-endian stream and StreamWriterBE to read from a
  *  BE stream. Alternatively, there is StreamWriterAny if the endianess of the output
  *  stream is to be determined at runtime.
  */
@@ -72,7 +72,7 @@ public:
 
 	// ---------------------------------------------------------------------
 	/** Construction from a given stream with a well-defined endianess.
-	 * 
+	 *
 	 *  The StreamReader holds a permanent strong reference to the
 	 *  stream, which is released upon destruction.
 	 *  @param stream Input stream. The stream is not re-seeked and writing
@@ -86,7 +86,7 @@ public:
 		, le(le)
 		, cursor()
 	{
-		ai_assert(stream); 
+		ai_assert(stream);
 		buffer.reserve(INITIAL_CAPACITY);
 	}
 
@@ -175,7 +175,7 @@ public:
 	/** overload operator<< and allow chaining of MM ops. */
 	template <typename T>
 	StreamWriter& operator << (T f) {
-		Put(f); 
+		Put(f);
 		return *this;
 	}
 
@@ -196,7 +196,7 @@ private:
 	template <typename T>
 	void Put(T f)	{
 		Intern :: Getter<SwapEndianess,T,RuntimeSwitch>() (&f, le);
-		
+
 		if (cursor + sizeof(T) >= buffer.size()) {
 			buffer.resize(cursor + sizeof(T));
 		}

code/StringComparison.h

@@ -51,6 +51,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INCLUDED_AI_STRING_WORKERS_H
 
 #include "../include/assimp/ai_assert.h"
+#include "StringComparison.h"
+
 #include <string.h>
 #include <stdint.h>
 #include <string>

code/TextureTransform.cpp

@@ -42,11 +42,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 
-#include "TextureTransform.h"
+#include <assimp/Importer.hpp>
-#include "../include/assimp/postprocess.h"
+#include <assimp/postprocess.h>
-#include "../include/assimp/DefaultLogger.hpp"
+#include <assimp/DefaultLogger.hpp>
-#include "../include/assimp/scene.h"
+#include <assimp/scene.h>
 
+#include "TextureTransform.h"
 
 using namespace Assimp;
 

code/UnrealLoader.cpp

@@ -54,11 +54,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "StreamReader.h"
 #include "ParsingUtils.h"
 #include "fast_atof.h"
-#include "ConvertToLHProcess.h"
+#include "ConvertToLHProcess.h"
-#include "../include/assimp/DefaultLogger.hpp"
+
-#include "../include/assimp/IOSystem.hpp"
+#include <assimp/Importer.hpp>
-#include "../include/assimp/scene.h"
+#include <assimp/DefaultLogger.hpp>
-#include <boost/scoped_ptr.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/scene.h>
+
+#include <boost/scoped_ptr.hpp>
 
 using namespace Assimp;
 

code/XFileParser.cpp

@@ -50,7 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "Exceptional.h"
 #include <boost/format.hpp>
 #include <boost/lexical_cast.hpp>
-#include "ByteSwap.h"
+#include "ByteSwapper.h"
 #include "../include/assimp/DefaultLogger.hpp"
 
 

code/fast_atof.h

@@ -255,7 +255,7 @@ inline int64_t strtol10_64(const char* in, const char** out = 0, unsigned int* m
 // If you find any bugs, please send them to me, niko (at) irrlicht3d.org.
 // ------------------------------------------------------------------------------------
 template <typename Real>
-inline const char* fast_atoreal_move( const char* c, Real& out, bool check_comma = true)
+inline const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true)
 {
 	Real f = 0;
 
@@ -286,14 +286,14 @@ inline const char* fast_atoreal_move( const char* c, Real& out, bool check_comma
 	}
 
 	if (!(c[0] >= '0' && c[0] <= '9') &&
-	    !(c[0] == '.' && c[1] >= '0' && c[1] <= '9'))
+	    !((c[0] == '.' || (check_comma && c[0] == ',')) && c[1] >= '0' && c[1] <= '9'))
 	{
 		throw std::invalid_argument("Cannot parse string "
 		                            "as real number: does not start with digit "
 		                            "or decimal point followed by digit.");
 	}
 
-	if (*c != '.')
+	if (*c != '.' && (! check_comma || c[0] != ','))
 	{
 		f = static_cast<Real>( strtoul10_64 ( c, &c) );
 	}

contrib/openddlparser/code/DDLNode.cpp

@@ -153,7 +153,7 @@ Property *DDLNode::findPropertyByName( const std::string &name ) {
     }
     Property *current( m_properties );
     while( ddl_nullptr != current ) {
-        int res = strncmp( current->m_id->m_buffer, name.c_str(), name.size() );
+        int res = strncmp( current->m_key->m_text.m_buffer, name.c_str(), name.size() );
         if( 0 == res ) {
             return current;
         }

contrib/openddlparser/code/OpenDDLParser.cpp

@@ -87,7 +87,7 @@ static DDLNode *createDDLNode( Identifier *id, OpenDDLParser *parser ) {
         return ddl_nullptr;
     }
 
-    const std::string type( id->m_buffer );
+    const std::string type( id->m_text.m_buffer );
     DDLNode *parent( parser->top() );
     DDLNode *node = DDLNode::create( type, "", parent );
 
@@ -191,8 +191,6 @@ bool OpenDDLParser::parse() {
     
     normalizeBuffer( m_buffer );
 
-    std::cout << &m_buffer[0] << std::endl;
-
     m_context = new Context;
     m_context->m_root = DDLNode::create( "root", "", ddl_nullptr );
     pushNode( m_context->m_root );
@@ -217,7 +215,7 @@ char *OpenDDLParser::parseNextNode( char *in, char *end ) {
 
 static void dumpId( Identifier *id ) {
     if( ddl_nullptr != id ) {
-        std::cout << id->m_buffer << std::endl;
+        std::cout << id->m_text.m_buffer << std::endl;
     }
 }
 
@@ -277,7 +275,7 @@ char *OpenDDLParser::parseHeader( char *in, char *end ) {
         Name *name( ddl_nullptr );
         in = OpenDDLParser::parseName( in, end, &name );
         if( ddl_nullptr != name ) {
-            const std::string nodeName( name->m_id->m_buffer );
+            const std::string nodeName( name->m_id->m_text.m_buffer );
             node->setName( nodeName );
         }
     }
@@ -500,10 +498,8 @@ char *OpenDDLParser::parseIdentifier( char *in, char *end, Identifier **id ) {
         idLen++;
     }
     
-    const size_t len( idLen + 1 );
+    const size_t len( idLen );
-    Identifier *newId = new Identifier( len, new char[ len ] );
+    Identifier *newId = new Identifier( start, len );
-    ::strncpy( newId->m_buffer, start, newId->m_len-1 );
-    newId->m_buffer[ newId->m_len - 1 ] = '\0';
     *id = newId;
 
     return in;
@@ -714,7 +710,7 @@ char *OpenDDLParser::parseStringLiteral( char *in, char *end, Value **stringData
 static void createPropertyWithData( Identifier *id, Value *primData, Property **prop ) {
     if( ddl_nullptr != primData ) {
         ( *prop ) = new Property( id );
-        ( *prop )->m_primData = primData;
+        ( *prop )->m_value = primData;
     }
 }
 

contrib/openddlparser/include/openddlparser/OpenDDLCommon.h

@@ -26,6 +26,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include <cstddef>
 #include <vector>
+#include <string>
 
 #include <string.h>
 
@@ -77,41 +78,83 @@ enum NameType {
     LocalName
 };
 
-struct Token {
+struct Text {
-public:
+    size_t m_capacity;
-    Token( const char *token )
+    size_t m_len;
-    : m_token( token )
+    char *m_buffer;
-    , m_size( 0 ){
+
-        if( ddl_nullptr != token ) {
+    Text( const char *buffer, size_t numChars )
-            m_size = strlen( m_token );
+    : m_capacity( 0 )
+    , m_len( 0 )
+    , m_buffer( ddl_nullptr ) {
+        set( buffer, numChars );
+    }
+
+    ~Text() {
+        clear();
+    }
+
+    void clear() {
+        delete[] m_buffer;
+        m_buffer = ddl_nullptr;
+        m_capacity = 0;
+        m_len = 0;
+    }
+
+    void set( const char *buffer, size_t numChars ) {
+        clear();
+        if( numChars > 0 ) {
+            m_len = numChars;
+            m_capacity = m_len + 1;
+            m_buffer = new char[ m_capacity ];
+            strncpy( m_buffer, buffer, numChars );
+            m_buffer[ numChars ] = '\0';
         }
     }
-    
+
-    ~Token() {
+    bool operator == ( const std::string &name ) const {
-        // empty
+        if( m_len != name.size() ) {
+            return false;
+        }
+        const int res( strncmp( m_buffer, name.c_str(), name.size() ) );
+        return ( 0 == res );
+
     }
 
-    size_t length() const {
+    bool operator == ( const Text &rhs ) const {
-        return m_size;
+        if( m_len != rhs.m_len ) {
-    }
-
-    bool operator == ( const Token &rhs ) const {
-        if( m_size != rhs.m_size ) {
             return false;
         }
 
-        const int res( strncmp( m_token, rhs.m_token, m_size ) );
+        const int res ( strncmp( m_buffer, rhs.m_buffer, m_len ) );
-        return ( res == 0 );
+        return ( 0 == res );
     }
 
 private:
-    Token();
+    Text( const Text & );
-    Token( const Token  & );
+    Text &operator = ( const Text & );
-    Token &operator = ( const Token & );
+};
+
+struct Identifier {
+    Text m_text;
+
+    Identifier( char buffer[], size_t len )
+        : m_text( buffer, len ) {
+        // empty
+    }
+
+    Identifier( char buffer[] )
+    : m_text( buffer, strlen( buffer ) ) {
+        // empty
+    }
+
+    bool operator == ( const Identifier &rhs ) const {
+        return m_text == rhs.m_text;
+    }
 
 private:
-    const char *m_token;
+    Identifier( const Identifier & );
-    size_t m_size;
+    Identifier &operator = ( const Identifier & );
 };
 
 struct Name {
@@ -154,30 +197,15 @@ private:
     Reference &operator = ( const Reference & );
 };
 
-struct Identifier {
-    size_t m_len;
-    char *m_buffer;
-
-    Identifier( size_t len, char buffer[] )
-        : m_len( len )
-        , m_buffer( buffer ) {
-        // empty
-    }
-
-private:
-    Identifier( const Identifier & );
-    Identifier &operator = ( const Identifier & );
-};
-
 struct Property {
-    Identifier *m_id;
+    Identifier *m_key;
-    Value *m_primData;
+    Value *m_value;
     Reference *m_ref;
     Property *m_next;
 
     Property( Identifier *id )
-        : m_id( id )
+        : m_key( id )
-        , m_primData( ddl_nullptr )
+        , m_value( ddl_nullptr )
         , m_ref( ddl_nullptr )
         , m_next( ddl_nullptr ) {
         // empty

contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h

@@ -107,6 +107,12 @@ bool isNumeric( const T in ) {
     return false;*/
 }
 
+template<class T>
+inline
+bool isNotEndOfToken( T *in, T *end ) {
+    return ( '}' != *in && ',' != *in && !isSpace( *in ) && in != end );
+}
+
 template<class T>
 inline
 bool isInteger( T *in, T *end ) {
@@ -117,7 +123,8 @@ bool isInteger( T *in, T *end ) {
     }
 
     bool result( false );
-    while( '}' != *in && ',' != *in && !isSpace( *in ) && in != end ) {
+    while( isNotEndOfToken( in, end ) ) {
+        //while( '}' != *in && ',' != *in && !isSpace( *in ) && in != end ) {
         result = isNumeric( *in );
         if( !result ) {
             break;
@@ -139,7 +146,9 @@ bool isFloat( T *in, T *end ) {
 
     // check for <1>.0f
     bool result( false );
-    while( !isSpace( *in ) && in != end ) {
+    while( isNotEndOfToken( in, end ) ) {
+
+//    while( !isSpace( *in ) && in != end ) {
         if( *in == '.' ) {
             result = true;
             break;
@@ -159,7 +168,9 @@ bool isFloat( T *in, T *end ) {
     }
 
     // check for 1.<0>f
-    while( !isSpace( *in ) && in != end && *in != ',' ) {
+    while( isNotEndOfToken( in, end ) ) {
+
+//    while( !isSpace( *in ) && in != end && *in != ',' && *in != '}' ) {
         result = isNumeric( *in );
         if( !result ) {
             return false;

doc/dox.h

@@ -9,14 +9,14 @@
 
 @section intro Introduction
 
-assimp is a library to load and process geometric scenes from various data formats. It is tailored at typical game 
+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 
+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 
+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>
@@ -39,15 +39,15 @@ that it has not been implemented yet and some (most ...) formats lack proper spe
 <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>DirectX X </b> ( <i>*.x</i> ). <br>
-<b>Quick3D </b> ( <i>*.q3o;*q3s</i> ). <br>	
+<b>Quick3D </b> ( <i>*.q3o;*q3s</i> ). <br>
-<b>Raw Triangles </b> ( <i>*.raw</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>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>
@@ -60,9 +60,9 @@ that it has not been implemented yet and some (most ...) formats lack proper spe
 <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. 
+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, 
+Note that although this paper claims to be the official documentation,
-http://assimp.sourceforge.net/main_features_formats.html 
+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>
@@ -71,12 +71,12 @@ http://assimp.sourceforge.net/main_features_formats.html
 <br>
 <hr>
 
-assimp is independent of the Operating System by nature, providing a C++ interface for easy integration 
+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 
+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 
+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. 
+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 
+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
@@ -89,14 +89,14 @@ but not all of them are *open-source*. If there's an accompagning '<file>\source
 
 @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 
+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 
+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 
+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.
@@ -104,7 +104,7 @@ there are no bindings for any other language provided. Have a look at the @link
 @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 
+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
@@ -118,7 +118,7 @@ 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 
+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>.
@@ -146,18 +146,18 @@ project configs. For static linking, use release/debug. See the sections below o
 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 
+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. 
+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 
+@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 
+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
@@ -168,39 +168,39 @@ _SECURE_SCL=0
 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! 
+<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. 
+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 
+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 
+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 
+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 
+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 
+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 
+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 
+<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. 
+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 
+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 
+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 
+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.
@@ -221,7 +221,7 @@ The Boost-Workaround consists of dummy replacements for some boost utility templ
 
 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: 
+your compiler's list of predefined macros:
 @code
 #define ASSIMP_BUILD_BOOST_WORKAROUND
 @endcode
@@ -240,7 +240,7 @@ for more details.
 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, 
+<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>.
 
@@ -260,19 +260,19 @@ 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, 
+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 
+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 
+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. 
+results and then simply let it go out of scope.
 
 C++ example:
 @code
@@ -286,14 +286,14 @@ bool DoTheImportThing( const std::string& pFile)
   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 
+  // 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, 
+  const aiScene* scene = importer.ReadFile( pFile,
-	aiProcess_CalcTangentSpace       | 
+	aiProcess_CalcTangentSpace       |
 	aiProcess_Triangulate            |
 	aiProcess_JoinIdenticalVertices  |
 	aiProcess_SortByPType);
-  
+
   // If the import failed, report it
   if( !scene)
   {
@@ -301,7 +301,7 @@ bool DoTheImportThing( const std::string& pFile)
     return false;
   }
 
-  // Now we can access the file's contents. 
+  // Now we can access the file's contents.
   DoTheSceneProcessing( scene);
 
   // We're done. Everything will be cleaned up by the importer destructor
@@ -312,9 +312,9 @@ bool DoTheImportThing( const std::string& pFile)
 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 
+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 
+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). 
+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
 
@@ -336,8 +336,8 @@ 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, 
+  const aiScene* scene = aiImportFile( pFile,
-    aiProcess_CalcTangentSpace       | 
+    aiProcess_CalcTangentSpace       |
 	aiProcess_Triangulate            |
 	aiProcess_JoinIdenticalVertices  |
 	aiProcess_SortByPType);
@@ -363,7 +363,7 @@ bool DoTheImportThing( const char* pFile)
 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 
+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
@@ -397,25 +397,25 @@ class MyIOSystem : public Assimp::IOSystem
 
   // 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 { 
+  char GetOsSeparator() const {
-    return '/'; 
+    return '/';
   }
 
   // ... and finally a method to open a custom stream
   IOStream* Open( const std::string& pFile, const std::string& pMode) {
-	return new MyIOStream( ... ); 
+	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 
+Now that your IO system is implemented, supply an instance of it to the Importer object by calling
-Assimp::Importer::SetIOHandler(). 
+Assimp::Importer::SetIOHandler().
 
 @code
 void DoTheImportThing( const std::string& pFile)
@@ -441,18 +441,18 @@ surely enough for almost any purpose. The process is simple:
 <li> .. and pass it as parameter to #aiImportFileEx
 </ul>
 
-@section  logging Logging 
+@section  logging Logging
 
-The assimp library provides an easy mechanism to log messages. For instance if you want to check the state of your 
+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 
+import and you just want to see, after which preprocessing step the import-process was aborted you can take a look
-into the log. 
+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 
+// Create a logger instance
 DefaultLogger::create("",Logger::VERBOSE);
 
 // Now I am ready for logging my stuff
@@ -462,12 +462,12 @@ DefaultLogger::get()->info("this is my info-call");
 DefaultLogger::kill();
 @endcode
 
-At first you have to create the default-logger-instance (create). Now you are ready to rock and can log a 
+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. 
+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
@@ -481,7 +481,7 @@ public:
 	{
 		// empty
 	}
-	
+
 	// Destructor
 	~myStream()
 	{
@@ -504,9 +504,9 @@ 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 
+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 
+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 
+a self defined logstream from an error severity by detaching it with the severity
 flag set:
 
 @code
@@ -519,10 +519,10 @@ Assimp::DefaultLogger::get()->attachStream( new myStream(), severity );
 
 @endcode
 
-If you want to implement your own logger just derive from the abstract base class 
+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. 
+#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 
+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
@@ -531,17 +531,17 @@ Assimp::DefaultLogger::get()->setLogSeverity( LogSeverity log_severity );
 
 @endcode
 
-The normal logging severity supports just the basic stuff like, info, warnings and errors. 
+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 
+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.
 
@@ -555,17 +555,17 @@ DirectX. If you need the imported data to be in a left-handed coordinate system,
 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. 
+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 
+0y|1y ---------- 1x|1y
  |                |
  |                |
  |                |
@@ -582,31 +582,31 @@ 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) 
+... 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. 
+<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, 
+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. 
+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. 
+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. 
+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. 
+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
@@ -646,7 +646,7 @@ void CopyNodesWithMeshes( aiNode node, SceneObject targetParent, Matrix4x4 accTr
 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 
+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
@@ -662,7 +662,7 @@ An aiMesh is defined by a series of data channels. The presence of these data ch
 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 
+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
@@ -677,9 +677,9 @@ 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 
+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. 
+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. 
+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
@@ -687,7 +687,7 @@ nodes which are not used by a bone in the mesh, but still affect the pose of the
 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. 
+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>
@@ -697,11 +697,11 @@ 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  
+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. 
+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 - 
+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.
@@ -719,12 +719,12 @@ though, that certain combinations of file format and exporter don't always store
 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 
+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. 
+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>
@@ -733,7 +733,7 @@ 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 
+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.
@@ -742,7 +742,7 @@ need them at all.
 
 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. 
+Such textures are loaded into an aiTexture structure.
 <br>
 There are two cases:
 <br>
@@ -769,12 +769,12 @@ 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. 
+All materials are stored in an array of aiMaterial inside the aiScene.
 
-Each aiMesh refers to one 
+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 
+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.
 
@@ -788,13 +788,13 @@ Textures are organized in stacks, each stack being evaluated independently. The
 
 ------------------------
 | Constant base color  |             color
------------------------- 
+------------------------
 | Blend operation 0    |             +
 ------------------------
 | Strength factor 0    |             0.25*
 ------------------------
 | Texture 0            |             texture_0
------------------------- 
+------------------------
 | Blend operation 1    |             *
 ------------------------
 | Strength factor 1    |             1.0*
@@ -807,7 +807,7 @@ Textures are organized in stacks, each stack being evaluated independently. The
 
 @section keys Constants
 
-All material key constants start with 'AI_MATKEY' (it's an ugly macro for historical reasons, don't ask). 
+All material key constants start with 'AI_MATKEY' (it's an ugly macro for historical reasons, don't ask).
 
 <table border="1">
   <tr>
@@ -857,7 +857,7 @@ All material key constants start with 'AI_MATKEY' (it's an ugly macro for histor
     <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 
+	<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>
@@ -1034,7 +1034,7 @@ 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!). 
+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
@@ -1085,15 +1085,15 @@ for all textures
    have uvwsrc for this texture?
       assign channel specified in uvwsrc
    else
-      assign channels in ascending order for all texture stacks, 
+      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 
+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 
+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.
@@ -1111,7 +1111,7 @@ float3 EvaluateStack(stack)
   for (every texture in stack)
   {
     // assuming we have explicit & pretransformed UVs for this texture
-    float3 color = SampleTexture(texture,uv); 
+    float3 color = SampleTexture(texture,uv);
 
     // scale by texture blend factor
     color *= texture.blend;
@@ -1207,7 +1207,7 @@ float4 PimpMyPixel (float4 prev)
 
   // Get all single light contribution terms
   float3 diff = ComputeDiffuseContribution();
-  float3 spec = ComputeSpecularContribution(); 
+  float3 spec = ComputeSpecularContribution();
   float3 ambi = ComputeAmbientContribution();
 
   // .. and compute the final color value for this pixel
@@ -1231,7 +1231,7 @@ float4 PimpMyPixel (float4 prev)
 
 
 
-/** 
+/**
 @page perf Performance
 
 @section perf_overview Overview
@@ -1243,9 +1243,9 @@ This page discusses general performance issues related to assimp.
 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.). 
+for the details.).
 
-Note that these measurements are based on a single run of the importer and each of the post processing steps, so 
+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.
@@ -1269,7 +1269,7 @@ Info,  T5488: Entering post processing pipeline
 
 Debug, T5488: START `postprocess`
 Debug, T5488: RemoveRedundantMatsProcess begin
-Debug, T5488: RemoveRedundantMatsProcess finished 
+Debug, T5488: RemoveRedundantMatsProcess finished
 Debug, T5488: END   `postprocess`, dt= 0.001 s
 
 
@@ -1306,7 +1306,7 @@ 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: ImproveCacheLocalityProcess finished.
 Debug, T5488: END   `postprocess`, dt= 1.903 s
 
 
@@ -1315,13 +1315,13 @@ 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 
+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. 
+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 
+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
@@ -1332,7 +1332,7 @@ 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: 
+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
@@ -1344,9 +1344,9 @@ following prerequisites are fulfilled:
 
 
 
-Multiple concurrent imports may or may not be beneficial, however. For certain file formats in conjunction with 
+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 
+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.  
+with 'slow' file formats like X or Collada might scale well with multiple concurrent imports.
 
 
 @section automt Internal threading
@@ -1357,8 +1357,8 @@ 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, 
+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 
+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.
@@ -1376,14 +1376,14 @@ mailing list or on our forums on SF.net.
 <hr>
 @section blender Blender
 
-This section contains implementation notes for the Blender3D importer. 
+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/). 
+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, 
+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 
+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
@@ -1397,12 +1397,12 @@ When filing bugs on the Blender loader, always give the Blender version (or, eve
 <hr>
 @section ifc IFC
 
-This section contains implementation notes on the IFC-STEP importer. 
+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 
+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 
+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. 
+at getting as much 3D data out of the files as possible.
 
 @subsection ifc_status Current status
 
@@ -1413,23 +1413,23 @@ IFC support is new and considered experimental. Please report any bugs you may e
 - 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 
+- 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). 
+- 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, 
+- 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. 
+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. 
+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
 
@@ -1481,12 +1481,12 @@ Just look in OgreImporterMaterial.cpp
 -	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. 
+	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 
+	If there
-	is no material file with the same name as the material, Ogre Importer will 
+	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.
@@ -1515,8 +1515,8 @@ OK, that sounds too easy :-). The whole procedure for a new loader merely looks
 <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, 
+<li>Open Importer.cpp and include your header just below the <i>(include_new_importers_here)</i> line,
-guarded by a #define 
+guarded by a #define
 @code
 #if (!defined assimp_BUILD_NO_FormatName_IMPORTER)
 	...
@@ -1525,14 +1525,14 @@ guarded by a #define
 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 
+<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(). 
+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
@@ -1566,7 +1566,7 @@ store the properties as a member variable of your importer, they are thread safe
 <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. 
+<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>
 
@@ -1586,11 +1586,11 @@ Don't trust the input data! Check all offsets!
 
 Mixed stuff for internal use by loaders, mostly documented (most of them are already included by <i>AssimpPCH.h</i>):
 <ul>
-<li><b>ByteSwap</b> (<i>ByteSwap.h</i>) - manual byte swapping stuff for binary loaders.</li>
+<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 
+<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>
@@ -1640,8 +1640,8 @@ The boost whitelist:
 
 @code
 // -------------------------------------------------------------------------------
-// Returns whether the class can handle the format of the given file. 
+// Returns whether the class can handle the format of the given file.
-bool xxxxImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, 
+bool xxxxImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler,
 	bool checkSig) const
 {
 	const std::string extension = GetExtension(pFile);
@@ -1649,8 +1649,8 @@ bool xxxxImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler,
 		return true;
 	}
 	if (!extension.length() || checkSig) {
-		// no extension given, or we're called a second time because no 
+		// no extension given, or we're called a second time because no
-		// suitable loader was found yet. This means, we're trying to open 
+		// 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:
 		//
@@ -1659,11 +1659,11 @@ bool xxxxImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler,
 		// 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 
+		// 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 
+		// These checks MUST be done (even if !checkSig) if the file extension
-		// is not exclusive to your format. For example, .xml is very common 
+		// is not exclusive to your format. For example, .xml is very common
 		// and (co)used by many formats.
 	}
 	return false;
@@ -1677,7 +1677,7 @@ void xxxxImporter::GetExtensionList(std::set<std::string>& extensions)
 }
 
 // -------------------------------------------------------------------------------
-void xxxxImporter::InternReadFile( const std::string& pFile, 
+void xxxxImporter::InternReadFile( const std::string& pFile,
 	aiScene* pScene, IOSystem* pIOHandler)
 {
 	boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
@@ -1686,20 +1686,20 @@ void xxxxImporter::InternReadFile( const std::string& pFile,
 	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 
+	// 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" />
- 
+
- **/
+ **/

include/assimp/Exporter.hpp

@@ -348,16 +348,14 @@ public:
 	 *   are defined in the aiConfig.g header (all constants share the
 	 *   prefix AI_CONFIG_XXX and are simple strings).
 	 * @param iValue New value of the property
-	 * @param bWasExisting Optional pointer to receive true if the
+	 * @return true if the property was set before. The new value replaces
-	 *   property was set before. The new value replaces the previous value
+	 *   the previous value in this case.
-	 *   in this case.
 	 * @note Property of different types (float, int, string ..) are kept
 	 *   on different stacks, so calling SetPropertyInteger() for a 
 	 *   floating-point property has no effect - the loader will call
 	 *   GetPropertyFloat() to read the property, but it won't be there.
 	 */
-	void SetPropertyInteger(const char* szName, int iValue, 
+	bool SetPropertyInteger(const char* szName, int iValue);
-		bool* bWasExisting = NULL);
 
 	// -------------------------------------------------------------------
 	/** Set a boolean configuration property. Boolean properties
@@ -366,30 +364,27 @@ public:
 	 *  #GetPropertyBool and vice versa.
 	 * @see SetPropertyInteger()
 	 */
-	void SetPropertyBool(const char* szName, bool value, bool* bWasExisting = NULL)	{
+	bool SetPropertyBool(const char* szName, bool value)	{
-		SetPropertyInteger(szName,value,bWasExisting);
+		return SetPropertyInteger(szName,value);
 	}
 
 	// -------------------------------------------------------------------
 	/** Set a floating-point configuration property.
 	 * @see SetPropertyInteger()
 	 */
-	void SetPropertyFloat(const char* szName, float fValue, 
+	bool SetPropertyFloat(const char* szName, float fValue);
-		bool* bWasExisting = NULL);
 
 	// -------------------------------------------------------------------
 	/** Set a string configuration property.
 	 * @see SetPropertyInteger()
 	 */
-	void SetPropertyString(const char* szName, const std::string& sValue, 
+	bool SetPropertyString(const char* szName, const std::string& sValue);
-		bool* bWasExisting = NULL);
 
 	// -------------------------------------------------------------------
 	/** Set a matrix configuration property.
 	 * @see SetPropertyInteger()
 	 */
-	void SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue, 
+	bool SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue);
-		bool* bWasExisting = NULL);
 
 	// -------------------------------------------------------------------
 	/** Get a configuration property.

include/assimp/Importer.hpp

@@ -194,16 +194,14 @@ public:
 	 *   are defined in the aiConfig.g header (all constants share the
 	 *   prefix AI_CONFIG_XXX and are simple strings).
 	 * @param iValue New value of the property
-	 * @param bWasExisting Optional pointer to receive true if the
+	 * @return true if the property was set before. The new value replaces
-	 *   property was set before. The new value replaces the previous value
+	 *   the previous value in this case.
-	 *   in this case.
 	 * @note Property of different types (float, int, string ..) are kept
 	 *   on different stacks, so calling SetPropertyInteger() for a 
 	 *   floating-point property has no effect - the loader will call
 	 *   GetPropertyFloat() to read the property, but it won't be there.
 	 */
-	void SetPropertyInteger(const char* szName, int iValue, 
+	bool SetPropertyInteger(const char* szName, int iValue);
-		bool* bWasExisting = NULL);
 
 	// -------------------------------------------------------------------
 	/** Set a boolean configuration property. Boolean properties
@@ -212,30 +210,27 @@ public:
 	 *  #GetPropertyBool and vice versa.
 	 * @see SetPropertyInteger()
 	 */
-	void SetPropertyBool(const char* szName, bool value, bool* bWasExisting = NULL)	{
+	bool SetPropertyBool(const char* szName, bool value)	{
-		SetPropertyInteger(szName,value,bWasExisting);
+		return SetPropertyInteger(szName,value);
 	}
 
 	// -------------------------------------------------------------------
 	/** Set a floating-point configuration property.
 	 * @see SetPropertyInteger()
 	 */
-	void SetPropertyFloat(const char* szName, float fValue, 
+	bool SetPropertyFloat(const char* szName, float fValue);
-		bool* bWasExisting = NULL);
 
 	// -------------------------------------------------------------------
 	/** Set a string configuration property.
 	 * @see SetPropertyInteger()
 	 */
-	void SetPropertyString(const char* szName, const std::string& sValue, 
+	bool SetPropertyString(const char* szName, const std::string& sValue);
-		bool* bWasExisting = NULL);
 
 	// -------------------------------------------------------------------
 	/** Set a matrix configuration property.
 	 * @see SetPropertyInteger()
 	 */
-	void SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue, 
+	bool SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue);
-		bool* bWasExisting = NULL);
 
 	// -------------------------------------------------------------------
 	/** Get a configuration property.

include/assimp/config.h

@@ -877,8 +877,24 @@ enum aiComponent
  */
 #define AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION "IMPORT_IFC_CUSTOM_TRIANGULATION"
 
+// ---------------------------------------------------------------------------
+/** @brief Specifies whether the Collada loader will ignore the provided up direction.
+ *
+ * If this property is set to true, the up direction provided in the file header will
+ * be ignored and the file will be loaded as is.
+ * Property type: Bool. Default value: false.
+ */
 #define AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION "IMPORT_COLLADA_IGNORE_UP_DIRECTION"
-
+
+// ---------------------------------------------------------------------------
+/** @brief Specifies whether the Collada loader will invert the transparency value.
+ *
+ * If this property is set to true, the transparency value will be interpreted as the
+ * inverse of the usual transparency. This is useful because lots of exporters does
+ * not respect the standard and do the opposite of what is normally expected.
+ * Property type: Bool. Default value: false.
+ */
+#define AI_CONFIG_IMPORT_COLLADA_INVERT_TRANSPARENCY "IMPORT_COLLADA_INVERT_TRANSPARENCY"
 
 // ---------- All the Export defines ------------
 
@@ -887,7 +903,6 @@ enum aiComponent
  * Property type: Bool. Default value: false.
  */
 
-#define AI_CONFIG_EXPORT_XFILE_64BIT "EXPORT_XFILE_64BIT"
+#define AI_CONFIG_EXPORT_XFILE_64BIT "EXPORT_XFILE_64BIT"
-
 
 #endif // !! AI_CONFIG_H_INC

test/unit/utImporter.cpp

@@ -131,21 +131,19 @@ TEST_F(ImporterTest, testMemoryRead)
 // ------------------------------------------------------------------------------------------------
 TEST_F(ImporterTest, testIntProperty)
 {
-	bool b;
+	bool b = pImp->SetPropertyInteger("quakquak",1503);
-	pImp->SetPropertyInteger("quakquak",1503,&b);
 	EXPECT_FALSE(b);
 	EXPECT_EQ(1503, pImp->GetPropertyInteger("quakquak",0));
 	EXPECT_EQ(314159, pImp->GetPropertyInteger("not_there",314159));
 
-	pImp->SetPropertyInteger("quakquak",1504,&b);
+	b = pImp->SetPropertyInteger("quakquak",1504);
 	EXPECT_TRUE(b);
 }
 
 // ------------------------------------------------------------------------------------------------
 TEST_F(ImporterTest, testFloatProperty)
 {
-	bool b;
+	bool b = pImp->SetPropertyFloat("quakquak",1503.f);
-	pImp->SetPropertyFloat("quakquak",1503.f,&b);
 	EXPECT_TRUE(!b);
 	EXPECT_EQ(1503.f, pImp->GetPropertyFloat("quakquak",0.f));
 	EXPECT_EQ(314159.f, pImp->GetPropertyFloat("not_there",314159.f));
@@ -154,8 +152,7 @@ TEST_F(ImporterTest, testFloatProperty)
 // ------------------------------------------------------------------------------------------------
 TEST_F(ImporterTest, testStringProperty)
 {
-	bool b;
+	bool b = pImp->SetPropertyString("quakquak","test");
-	pImp->SetPropertyString("quakquak","test",&b);
 	EXPECT_TRUE(!b);
 	EXPECT_EQ("test", pImp->GetPropertyString("quakquak","weghwekg"));
 	EXPECT_EQ("ILoveYou", pImp->GetPropertyString("not_there","ILoveYou"));

tools/assimp_view/AnimEvaluator.cpp

@@ -39,7 +39,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-#include "stdafx.h"
 #include "assimp_view.h"
 
 using namespace AssimpView;

tools/assimp_view/AssetHelper.h

@@ -43,195 +43,204 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #if (!defined AV_ASSET_HELPER_H_INCLUDED)
 #define AV_ASSET_HELPER_H_INCLUDED
 
-class SceneAnimator;
+#include <d3d9.h>
+#include <d3dx9.h>
+#include <d3dx9mesh.h>
 
-//-------------------------------------------------------------------------------
+#include <assimp/scene.h>
-/**	\brief Class to wrap ASSIMP's asset output structures
-*/
-//-------------------------------------------------------------------------------
-class AssetHelper
-	{
-	public:
-		enum 
-		{
-			// the original normal set will be used
-			ORIGINAL = 0x0u,
 
-			// a smoothed normal set will be used
+namespace AssimpView {
-			SMOOTH = 0x1u,
 
-			// a hard normal set will be used
+    class SceneAnimator;
-			HARD = 0x2u,
-		};
 
-		// default constructor
+    //-------------------------------------------------------------------------------
-		AssetHelper()
+    /**	\brief Class to wrap ASSIMP's asset output structures
-			: iNormalSet(ORIGINAL)
+    */
-		{
+    //-------------------------------------------------------------------------------
-			mAnimator = NULL;
+    class AssetHelper
-			apcMeshes = NULL;
+    {
-			pcScene = NULL;
+    public:
-		}
+        enum
+        {
+            // the original normal set will be used
+            ORIGINAL = 0x0u,
 
-		//---------------------------------------------------------------
+            // a smoothed normal set will be used
-		// default vertex data structure
+            SMOOTH = 0x1u,
-		// (even if tangents, bitangents or normals aren't
-		// required by the shader they will be committed to the GPU)
-		//---------------------------------------------------------------
-		struct Vertex
-		{
-			aiVector3D vPosition;
-			aiVector3D vNormal;
 
-			D3DCOLOR dColorDiffuse;
+            // a hard normal set will be used
-			aiVector3D vTangent;
+            HARD = 0x2u,
-			aiVector3D vBitangent;
+        };
-			aiVector2D vTextureUV;
-			aiVector2D vTextureUV2;
-			unsigned char mBoneIndices[4];
-			unsigned char mBoneWeights[4]; // last Weight not used, calculated inside the vertex shader
 
-			/** Returns the vertex declaration elements to create a declaration from. */
+        // default constructor
-			static D3DVERTEXELEMENT9* GetDeclarationElements() 
+        AssetHelper()
-			{
+            : iNormalSet( ORIGINAL )
-				static D3DVERTEXELEMENT9 decl[] =
+        {
-				{
+            mAnimator = NULL;
-					{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
+            apcMeshes = NULL;
-					{ 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 },
+            pcScene = NULL;
-					{ 0, 24, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
+        }
-					{ 0, 28, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0 },
-					{ 0, 40, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0 },
-					{ 0, 52, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
-					{ 0, 60, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1 },
-					{ 0, 68, D3DDECLTYPE_UBYTE4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES, 0 },
-					{ 0, 72, D3DDECLTYPE_UBYTE4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0 },
-					D3DDECL_END()
-				};
 
-				return decl;
+        //---------------------------------------------------------------
-			}
+        // default vertex data structure
-		};
+        // (even if tangents, bitangents or normals aren't
+        // required by the shader they will be committed to the GPU)
+        //---------------------------------------------------------------
+        struct Vertex
+        {
+            aiVector3D vPosition;
+            aiVector3D vNormal;
 
-		//---------------------------------------------------------------
+            D3DCOLOR dColorDiffuse;
-		// FVF vertex structure used for normals
+            aiVector3D vTangent;
-		//---------------------------------------------------------------
+            aiVector3D vBitangent;
-		struct LineVertex
+            aiVector2D vTextureUV;
-		{
+            aiVector2D vTextureUV2;
-			aiVector3D vPosition;
+            unsigned char mBoneIndices[ 4 ];
-			DWORD dColorDiffuse;
+            unsigned char mBoneWeights[ 4 ]; // last Weight not used, calculated inside the vertex shader
 
-			// retrieves the FVF code of the vertex type
+            /** Returns the vertex declaration elements to create a declaration from. */
-			static DWORD GetFVF()
+            static D3DVERTEXELEMENT9* GetDeclarationElements()
-			{
+            {
-				return D3DFVF_DIFFUSE | D3DFVF_XYZ;
+                static D3DVERTEXELEMENT9 decl[] =
-			}
+                {
-		};
+                    { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
+                    { 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 },
+                    { 0, 24, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
+                    { 0, 28, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0 },
+                    { 0, 40, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0 },
+                    { 0, 52, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
+                    { 0, 60, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1 },
+                    { 0, 68, D3DDECLTYPE_UBYTE4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES, 0 },
+                    { 0, 72, D3DDECLTYPE_UBYTE4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0 },
+                    D3DDECL_END()
+                };
 
-		//---------------------------------------------------------------
+                return decl;
-		// Helper class to store GPU related resources created for
+            }
-		// a given aiMesh
+        };
-		//---------------------------------------------------------------
-		class MeshHelper
-			{
-			public:
 
-				MeshHelper ()
+        //---------------------------------------------------------------
-					: 
+        // FVF vertex structure used for normals
-					piVB				(NULL),
+        //---------------------------------------------------------------
-					piIB				(NULL),
+        struct LineVertex
-					piVBNormals			(NULL),
+        {
-					piEffect			(NULL),
+            aiVector3D vPosition;
-					bSharedFX           (false),
+            DWORD dColorDiffuse;
-					piDiffuseTexture	(NULL),
-					piSpecularTexture	(NULL),
-					piAmbientTexture	(NULL),
-					piEmissiveTexture	(NULL),
-					piNormalTexture		(NULL),
-					piOpacityTexture	(NULL),
-					piShininessTexture	(NULL),
-					piLightmapTexture	(NULL),
-					twosided            (false),
-					pvOriginalNormals	(NULL)
-                {}
 
-				~MeshHelper ()
+            // retrieves the FVF code of the vertex type
-					{
+            static DWORD GetFVF()
-					// NOTE: This is done in DeleteAssetData()
+            {
-					// TODO: Make this a proper d'tor
+                return D3DFVF_DIFFUSE | D3DFVF_XYZ;
-					}
+            }
+        };
 
-				// shading mode to use. Either Lambert or otherwise phong
+        //---------------------------------------------------------------
-				// will be used in every case
+        // Helper class to store GPU related resources created for
-				aiShadingMode eShadingMode;
+        // a given aiMesh
+        //---------------------------------------------------------------
+        class MeshHelper
+        {
+        public:
 
-				// vertex buffer
+            MeshHelper()
-				IDirect3DVertexBuffer9* piVB;
+                :
+                piVB( NULL ),
+                piIB( NULL ),
+                piVBNormals( NULL ),
+                piEffect( NULL ),
+                bSharedFX( false ),
+                piDiffuseTexture( NULL ),
+                piSpecularTexture( NULL ),
+                piAmbientTexture( NULL ),
+                piEmissiveTexture( NULL ),
+                piNormalTexture( NULL ),
+                piOpacityTexture( NULL ),
+                piShininessTexture( NULL ),
+                piLightmapTexture( NULL ),
+                twosided( false ),
+                pvOriginalNormals( NULL )
+            {}
 
-				// index buffer. For partially transparent meshes
+            ~MeshHelper()
-				// created with dynamic usage to be able to update
+            {
-				// the buffer contents quickly
+                // NOTE: This is done in DeleteAssetData()
-				IDirect3DIndexBuffer9* piIB;
+                // TODO: Make this a proper d'tor
+            }
 
-				// vertex buffer to be used to draw vertex normals
+            // shading mode to use. Either Lambert or otherwise phong
-				// (vertex normals are generated in every case)
+            // will be used in every case
-				IDirect3DVertexBuffer9* piVBNormals;
+            aiShadingMode eShadingMode;
 
-				// shader to be used
+            // vertex buffer
-				ID3DXEffect* piEffect;
+            IDirect3DVertexBuffer9* piVB;
-				bool bSharedFX;
 
-				// material textures
+            // index buffer. For partially transparent meshes
-				IDirect3DTexture9* piDiffuseTexture;
+            // created with dynamic usage to be able to update
-				IDirect3DTexture9* piSpecularTexture;
+            // the buffer contents quickly
-				IDirect3DTexture9* piAmbientTexture;
+            IDirect3DIndexBuffer9* piIB;
-				IDirect3DTexture9* piEmissiveTexture;
-				IDirect3DTexture9* piNormalTexture;
-				IDirect3DTexture9* piOpacityTexture;
-				IDirect3DTexture9* piShininessTexture;
-				IDirect3DTexture9* piLightmapTexture;
 
-				// material colors
+            // vertex buffer to be used to draw vertex normals
-				D3DXVECTOR4 vDiffuseColor;
+            // (vertex normals are generated in every case)
-				D3DXVECTOR4 vSpecularColor;
+            IDirect3DVertexBuffer9* piVBNormals;
-				D3DXVECTOR4 vAmbientColor;
-				D3DXVECTOR4 vEmissiveColor;
 
-				// opacity for the material
+            // shader to be used
-				float fOpacity;
+            ID3DXEffect* piEffect;
+            bool bSharedFX;
 
-				// shininess for the material
+            // material textures
-				float fShininess;
+            IDirect3DTexture9* piDiffuseTexture;
+            IDirect3DTexture9* piSpecularTexture;
+            IDirect3DTexture9* piAmbientTexture;
+            IDirect3DTexture9* piEmissiveTexture;
+            IDirect3DTexture9* piNormalTexture;
+            IDirect3DTexture9* piOpacityTexture;
+            IDirect3DTexture9* piShininessTexture;
+            IDirect3DTexture9* piLightmapTexture;
 
-				// strength of the specular highlight
+            // material colors
-				float fSpecularStrength;
+            D3DXVECTOR4 vDiffuseColor;
+            D3DXVECTOR4 vSpecularColor;
+            D3DXVECTOR4 vAmbientColor;
+            D3DXVECTOR4 vEmissiveColor;
 
-				// two-sided?
+            // opacity for the material
-				bool twosided;
+            float fOpacity;
 
-				// Stores a pointer to the original normal set of the asset
+            // shininess for the material
-				aiVector3D* pvOriginalNormals;
+            float fShininess;
-			};
 
-		// One instance per aiMesh in the globally loaded asset
+            // strength of the specular highlight
-		MeshHelper** apcMeshes;
+            float fSpecularStrength;
 
-		// Scene wrapper instance
+            // two-sided?
-		aiScene* pcScene;
+            bool twosided;
 
-		// Animation player to animate the scene if necessary
+            // Stores a pointer to the original normal set of the asset
-		SceneAnimator* mAnimator;
+            aiVector3D* pvOriginalNormals;
+        };
 
-		// Specifies the normal set to be used
+        // One instance per aiMesh in the globally loaded asset
-		unsigned int iNormalSet;
+        MeshHelper** apcMeshes;
 
-		// ------------------------------------------------------------------
+        // Scene wrapper instance
-		// set the normal set to be used
+        aiScene* pcScene;
-		void SetNormalSet(unsigned int iSet);
 
-		// ------------------------------------------------------------------
+        // Animation player to animate the scene if necessary
-		// flip all normal vectors
+        SceneAnimator* mAnimator;
-		void FlipNormals();
+
-		void FlipNormalsInt();
+        // Specifies the normal set to be used
-	};
+        unsigned int iNormalSet;
+
+        // ------------------------------------------------------------------
+        // set the normal set to be used
+        void SetNormalSet( unsigned int iSet );
+
+        // ------------------------------------------------------------------
+        // flip all normal vectors
+        void FlipNormals();
+        void FlipNormalsInt();
+    };
+}
 
 #endif // !! IG

tools/assimp_view/Background.cpp

@@ -39,12 +39,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-#include "stdafx.h"
 #include "assimp_view.h"
 
-
 namespace AssimpView {
 
+extern std::string g_szSkyboxShader;
 
 // From: U3D build 1256 (src\kernel\graphic\scenegraph\SkyBox.cpp)
 // ------------------------------------------------------------------------------

tools/assimp_view/Background.h

@@ -38,91 +38,91 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
+#pragma once
 
-#if (!defined AV_BACKGROUND_H_INCLUDED)
+namespace AssimpView
-#define AV_BACKGROUND_H_INCLUDED
+{
 
+    class CBackgroundPainter
+    {
+        CBackgroundPainter()
+            :
+            clrColor( D3DCOLOR_ARGB( 0xFF, 100, 100, 100 ) ),
+            pcTexture( NULL ),
+            piSkyBoxEffect( NULL ),
+            eMode( SIMPLE_COLOR )
+        {}
 
-class CBackgroundPainter
+    public:
-	{
-	CBackgroundPainter()
-		: 
-		clrColor(D3DCOLOR_ARGB(0xFF,100,100,100)),
-		pcTexture(NULL),
-		piSkyBoxEffect(NULL),
-		eMode(SIMPLE_COLOR)
-		{}
 
-public:
+        // Supported background draw modi
+        enum MODE { SIMPLE_COLOR, TEXTURE_2D, TEXTURE_CUBE };
 
-	// Supported background draw modi
+        // Singleton accessors
-	enum MODE {SIMPLE_COLOR, TEXTURE_2D, TEXTURE_CUBE};
+        static CBackgroundPainter s_cInstance;
+        inline static CBackgroundPainter& Instance()
+        {
+            return s_cInstance;
+        }
 
-	// Singleton accessors
+        // set the current background color
-	static CBackgroundPainter s_cInstance;
+        // (this removes any textures loaded)
-	inline static CBackgroundPainter& Instance ()
+        void SetColor( D3DCOLOR p_clrNew );
-		{
-		return s_cInstance;
-		}
 
-	// set the current background color
+        // Setup a cubemap/a 2d texture as background
-	// (this removes any textures loaded)
+        void SetCubeMapBG( const char* p_szPath );
-	void SetColor (D3DCOLOR p_clrNew);
+        void SetTextureBG( const char* p_szPath );
 
-	// Setup a cubemap/a 2d texture as background
+        // Called by the render loop
-	void SetCubeMapBG (const char* p_szPath);
+        void OnPreRender();
-	void SetTextureBG (const char* p_szPath);
+        void OnPostRender();
 
-	// Called by the render loop
+        // Release any native resources associated with the instance
-	void OnPreRender();
+        void ReleaseNativeResource();
-	void OnPostRender();
 
-	// Release any native resources associated with the instance
+        // Recreate any native resources associated with the instance
-	void ReleaseNativeResource();
+        void RecreateNativeResource();
 
-	// Recreate any native resources associated with the instance
+        // Rotate the skybox
-	void RecreateNativeResource();
+        void RotateSB( const aiMatrix4x4* pm );
 
-	// Rotate the skybox
+        // Reset the state of the skybox
-	void RotateSB(const aiMatrix4x4* pm);
+        void ResetSB();
 
-	// Reset the state of the skybox
+        inline MODE GetMode() const
-	void ResetSB();
+        {
+            return this->eMode;
+        }
 
-	inline MODE GetMode() const
+        inline IDirect3DBaseTexture9* GetTexture()
-		{
+        {
-		return this->eMode;
+            return this->pcTexture;
-		}
+        }
 
-	inline IDirect3DBaseTexture9* GetTexture()
+        inline ID3DXBaseEffect* GetEffect()
-		{
+        {
-		return this->pcTexture;
+            return this->piSkyBoxEffect;
-		}
+        }
 
-	inline ID3DXBaseEffect* GetEffect()
+    private:
-		{
-		return this->piSkyBoxEffect;
-		}
 
-private:
+        void RemoveSBDeps();
 
-	void RemoveSBDeps();
+        // current background color
+        D3DCOLOR clrColor;
 
-	// current background color
+        // current background texture
-	D3DCOLOR clrColor;
+        IDirect3DBaseTexture9* pcTexture;
+        ID3DXEffect* piSkyBoxEffect;
 
-	// current background texture
+        // current background mode
-	IDirect3DBaseTexture9* pcTexture;
+        MODE eMode;
-	ID3DXEffect* piSkyBoxEffect;
 
-	// current background mode
+        // path to the texture
-	MODE eMode;
+        std::string szPath;
 
-	// path to the texture
+        // transformation matrix for the skybox
-	std::string szPath;
+        aiMatrix4x4 mMatrix;
+    };
 
-	// transformation matrix for the skybox
+}
-	aiMatrix4x4 mMatrix;
-	};
-
-#endif // !! AV_BACKGROUND_H_INCLUDED

tools/assimp_view/Display.cpp

@@ -38,13 +38,16 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
-
-#include "stdafx.h"
 #include "assimp_view.h"
-
+#include "AnimEvaluator.h"
+#include "SceneAnimator.h"
 
 namespace AssimpView {
 
+using namespace Assimp;
+
+extern std::string g_szCheckerBackgroundShader;
+
 struct SVertex
 {
 	float x,y,z,w,u,v;
@@ -690,7 +693,7 @@ int CDisplay::FillDisplayList(void)
 	// fill in the first entry
 	TVITEMEX tvi; 
 	TVINSERTSTRUCT sNew;
-	tvi.pszText = "Model";
+	tvi.pszText = (char*) "Model";
 	tvi.cchTextMax = (int)strlen(tvi.pszText);
 	tvi.mask = TVIF_TEXT | TVIF_SELECTEDIMAGE | TVIF_IMAGE | TVIF_HANDLE | TVIF_STATE;
 	tvi.state = TVIS_EXPANDED;
@@ -2240,7 +2243,7 @@ int CDisplay::RenderTextureView()
 		const float ny = (float)sRect.bottom;
 		const float  x = (float)sDesc.Width;
 		const float  y = (float)sDesc.Height;
-		float f = std::min((nx-30) / x,(ny-30) / y) * (m_fTextureZoom/1000.0f);
+		float f = min((nx-30) / x,(ny-30) / y) * (m_fTextureZoom/1000.0f);
 
 		float fHalfX = (nx - (f * x)) / 2.0f;
 		float fHalfY = (ny - (f * y)) / 2.0f;

tools/assimp_view/Display.h

@@ -42,6 +42,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #if (!defined AV_DISPLAY_H_INCLUDED)
 #define AV_DISPLAY_H_INCLUDE
 
+#include <windows.h>
+#include <shellapi.h>
+#include <commctrl.h>
+
 // see CDisplay::m_aiImageList
 #define AI_VIEW_IMGLIST_NODE			0x0
 #define AI_VIEW_IMGLIST_MATERIAL		0x1
@@ -49,486 +53,490 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_VIEW_IMGLIST_TEXTURE_INVALID 0x3
 #define AI_VIEW_IMGLIST_MODEL			0x4
 
-//-------------------------------------------------------------------------------
+namespace AssimpView
-/* Corresponds to the "Display" combobox in the UI
+{
-*/
-//-------------------------------------------------------------------------------
-class CDisplay
-	{
-private:
 
-	// helper class
+    //-------------------------------------------------------------------------------
-	struct Info
+    /* Corresponds to the "Display" combobox in the UI
-	{
+    */
-		Info(	D3DXVECTOR4* p1,
+    //-------------------------------------------------------------------------------
-				AssetHelper::MeshHelper* p2,
+    class CDisplay
-				const char* p3)
+    {
-				: pclrColor(p1),pMesh(p2),szShaderParam(p3) {}
+    private:
 
-		D3DXVECTOR4* pclrColor;
+        // helper class
-		AssetHelper::MeshHelper* pMesh;
+        struct Info
-		const char* szShaderParam;
+        {
-	};
+            Info( D3DXVECTOR4* p1,
+                AssetHelper::MeshHelper* p2,
+                const char* p3 )
+                : pclrColor( p1 ), pMesh( p2 ), szShaderParam( p3 ) {}
 
-// default constructor
+            D3DXVECTOR4* pclrColor;
-	CDisplay() 
+            AssetHelper::MeshHelper* pMesh;
-		:	m_iViewMode(VIEWMODE_FULL), 
+            const char* szShaderParam;
-			m_pcCurrentTexture(NULL),
+        };
-			m_pcCurrentNode(NULL),
-			m_pcCurrentMaterial(NULL),
-			m_hImageList(NULL),
-			m_hRoot(NULL),
-			m_fTextureZoom(1000.0f)
-	{
-		this->m_aiImageList[0] = 0;
-		this->m_aiImageList[1] = 1;
-		this->m_aiImageList[2] = 2;
-		this->m_aiImageList[3] = 3;
-		this->m_aiImageList[4] = 4;
 
-		this->m_avCheckerColors[0].x = this->m_avCheckerColors[0].y = this->m_avCheckerColors[0].z = 0.4f;
+        // default constructor
-		this->m_avCheckerColors[1].x = this->m_avCheckerColors[1].y = this->m_avCheckerColors[1].z = 0.6f;
+        CDisplay()
-	}
+            : m_iViewMode( VIEWMODE_FULL ),
+            m_pcCurrentTexture( NULL ),
+            m_pcCurrentNode( NULL ),
+            m_pcCurrentMaterial( NULL ),
+            m_hImageList( NULL ),
+            m_hRoot( NULL ),
+            m_fTextureZoom( 1000.0f )
+        {
+            this->m_aiImageList[ 0 ] = 0;
+            this->m_aiImageList[ 1 ] = 1;
+            this->m_aiImageList[ 2 ] = 2;
+            this->m_aiImageList[ 3 ] = 3;
+            this->m_aiImageList[ 4 ] = 4;
 
-public:
+            this->m_avCheckerColors[ 0 ].x = this->m_avCheckerColors[ 0 ].y = this->m_avCheckerColors[ 0 ].z = 0.4f;
+            this->m_avCheckerColors[ 1 ].x = this->m_avCheckerColors[ 1 ].y = this->m_avCheckerColors[ 1 ].z = 0.6f;
+        }
+
+    public:
 
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	enum 
+        enum
-	{
+        {
-		// the full model is displayed
+            // the full model is displayed
-		VIEWMODE_FULL,
+            VIEWMODE_FULL,
 
-		// a material is displayed on a simple spjere as model
+            // a material is displayed on a simple spjere as model
-		VIEWMODE_MATERIAL,
+            VIEWMODE_MATERIAL,
 
-		// a texture with an UV set mapped on it is displayed
+            // a texture with an UV set mapped on it is displayed
-		VIEWMODE_TEXTURE,
+            VIEWMODE_TEXTURE,
 
-		// a single node in the scenegraph is displayed
+            // a single node in the scenegraph is displayed
-		VIEWMODE_NODE,
+            VIEWMODE_NODE,
-	};
+        };
 
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// represents a texture in the tree view
+        // represents a texture in the tree view
-	struct TextureInfo
+        struct TextureInfo
-	{
+        {
-		// texture info
+            // texture info
-		IDirect3DTexture9** piTexture;
+            IDirect3DTexture9** piTexture;
 
-		// Blend factor of the texture
+            // Blend factor of the texture
-		float fBlend;
+            float fBlend;
 
-		// blend operation for the texture
+            // blend operation for the texture
-		aiTextureOp eOp;
+            aiTextureOp eOp;
 
-		// UV index for the texture
+            // UV index for the texture
-		unsigned int iUV;
+            unsigned int iUV;
 
-		// Associated tree item
+            // Associated tree item
-		HTREEITEM hTreeItem;
+            HTREEITEM hTreeItem;
 
-		// Original path to the texture
+            // Original path to the texture
-		std::string szPath;
+            std::string szPath;
 
-		// index of the corresponding material
+            // index of the corresponding material
-		unsigned int iMatIndex;
+            unsigned int iMatIndex;
 
-		// type of the texture
+            // type of the texture
-		unsigned int iType;
+            unsigned int iType;
-	};
+        };
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// represents a node in the tree view
+        // represents a node in the tree view
-	struct NodeInfo
+        struct NodeInfo
-	{
+        {
-		// node object
+            // node object
-		aiNode* psNode;
+            aiNode* psNode;
 
-		// corresponding tree view item
+            // corresponding tree view item
-		HTREEITEM hTreeItem;
+            HTREEITEM hTreeItem;
-	};
+        };
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// represents a mesh in the tree view
+        // represents a mesh in the tree view
-	struct MeshInfo
+        struct MeshInfo
-	{
+        {
-		// the mesh object
+            // the mesh object
-		aiMesh* psMesh;
+            aiMesh* psMesh;
 
-		// corresponding tree view item
+            // corresponding tree view item
-		HTREEITEM hTreeItem;
+            HTREEITEM hTreeItem;
-	};
+        };
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// represents a material in the tree view
+        // represents a material in the tree view
-	struct MaterialInfo
+        struct MaterialInfo
-	{
+        {
-		// material index
+            // material index
-		unsigned int iIndex;
+            unsigned int iIndex;
 
-		// material object
+            // material object
-		aiMaterial* psMaterial;
+            aiMaterial* psMaterial;
 
-		// ID3DXEffect interface
+            // ID3DXEffect interface
-		ID3DXEffect* piEffect;
+            ID3DXEffect* piEffect;
 
-		// corresponding tree view item
+            // corresponding tree view item
-		HTREEITEM hTreeItem;
+            HTREEITEM hTreeItem;
-	};
+        };
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Singleton accessors
+        // Singleton accessors
-	static CDisplay s_cInstance;
+        static CDisplay s_cInstance;
-	inline static CDisplay& Instance ()
+        inline static CDisplay& Instance()
-		{
+        {
-		return s_cInstance;
+            return s_cInstance;
-		}
+        }
 
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Called during the render loop. Renders the scene (including the 
+        // Called during the render loop. Renders the scene (including the 
-	// HUD etc) in the current view mode
+        // HUD etc) in the current view mode
-	int OnRender();
+        int OnRender();
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// called when the user selects another item in the "Display" tree 
+        // called when the user selects another item in the "Display" tree 
-	// view the method determines the new view mode and performs all 
+        // view the method determines the new view mode and performs all 
-	// required operations
+        // required operations
-	// \param p_hTreeItem Selected tree view item
+        // \param p_hTreeItem Selected tree view item
-	int OnSetup(HTREEITEM p_hTreeItem);
+        int OnSetup( HTREEITEM p_hTreeItem );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Variant 1: Render the full scene with the asset
+        // Variant 1: Render the full scene with the asset
-	int RenderFullScene();
+        int RenderFullScene();
 
 #if 0
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Variant 2: Render only a part of the scene. One node to
+        // Variant 2: Render only a part of the scene. One node to
-	// be exact
+        // be exact
-	int RenderScenePart();
+        int RenderScenePart();
 #endif
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Variant 3: Render a large sphere and map a given material on it
+        // Variant 3: Render a large sphere and map a given material on it
-	int RenderMaterialView();
+        int RenderMaterialView();
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Variant 4: Render a flat plane, map a texture on it and
+        // Variant 4: Render a flat plane, map a texture on it and
-	// display the UV wire on it
+        // display the UV wire on it
-	int RenderTextureView();
+        int RenderTextureView();
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Fill the UI combobox with a list of all supported view modi
+        // Fill the UI combobox with a list of all supported view modi
-	//
+        //
-	// The display modes are added in order
+        // The display modes are added in order
-	int FillDisplayList(void);
+        int FillDisplayList( void );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Add a material and all sub textures to the display mode list
+        // Add a material and all sub textures to the display mode list
-	// hRoot - Handle to the root of the tree view
+        // hRoot - Handle to the root of the tree view
-	// iIndex - Material index
+        // iIndex - Material index
-	int AddMaterialToDisplayList(HTREEITEM hRoot, 
+        int AddMaterialToDisplayList( HTREEITEM hRoot,
-		unsigned int iIndex);
+            unsigned int iIndex );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Add a texture to the display list
+        // Add a texture to the display list
-	// pcMat - material containing the texture
+        // pcMat - material containing the texture
-	// hTexture - Handle to the material tree item
+        // hTexture - Handle to the material tree item
-	// szPath - Path to the texture
+        // szPath - Path to the texture
-	// iUVIndex - UV index to be used for the texture
+        // iUVIndex - UV index to be used for the texture
-	// fBlendFactor - Blend factor to be used for the texture
+        // fBlendFactor - Blend factor to be used for the texture
-	// eTextureOp - texture operation to be used for the texture
+        // eTextureOp - texture operation to be used for the texture
-	int AddTextureToDisplayList(unsigned int iType,
+        int AddTextureToDisplayList( unsigned int iType,
-		unsigned int iIndex,
+            unsigned int iIndex,
-		const aiString* szPath,
+            const aiString* szPath,
-		HTREEITEM hFX, 
+            HTREEITEM hFX,
-		unsigned int iUVIndex		= 0,
+            unsigned int iUVIndex = 0,
-		const float fBlendFactor	= 0.0f,
+            const float fBlendFactor = 0.0f,
-		aiTextureOp eTextureOp		= aiTextureOp_Multiply,
+            aiTextureOp eTextureOp = aiTextureOp_Multiply,
-		unsigned int iMesh			= 0);
+            unsigned int iMesh = 0 );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Add a node to the display list
+        // Add a node to the display list
-	// Recusrivly adds all subnodes as well
+        // Recusrivly adds all subnodes as well
-	// iIndex - Index of the node in the parent's child list
+        // iIndex - Index of the node in the parent's child list
-	// iDepth - Current depth of the node
+        // iDepth - Current depth of the node
-	// pcNode - Node object
+        // pcNode - Node object
-	// hRoot - Parent tree view node
+        // hRoot - Parent tree view node
-	int AddNodeToDisplayList(
+        int AddNodeToDisplayList(
-		unsigned int iIndex, 
+            unsigned int iIndex,
-		unsigned int iDepth,
+            unsigned int iDepth,
-		aiNode* pcNode,
+            aiNode* pcNode,
-		HTREEITEM hRoot);
+            HTREEITEM hRoot );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Add a mesh to the display list
+        // Add a mesh to the display list
-	// iIndex - Index of the mesh in the scene's mesh list
+        // iIndex - Index of the mesh in the scene's mesh list
-	// hRoot - Parent tree view node
+        // hRoot - Parent tree view node
-	int AddMeshToDisplayList(
+        int AddMeshToDisplayList(
-		unsigned int iIndex, 
+            unsigned int iIndex,
-		HTREEITEM hRoot);
+            HTREEITEM hRoot );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Load the image list for the tree view item
+        // Load the image list for the tree view item
-	int LoadImageList(void);
+        int LoadImageList( void );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Expand all nodes in the tree 
+        // Expand all nodes in the tree 
-	int ExpandTree();
+        int ExpandTree();
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Fill the UI combobox with a list of all supported animations
+        // Fill the UI combobox with a list of all supported animations
-	// The animations are added in order
+        // The animations are added in order
-	int FillAnimList(void);
+        int FillAnimList( void );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Clear the combox box containing the list of animations
+        // Clear the combox box containing the list of animations
-	int ClearAnimList(void);
+        int ClearAnimList( void );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Clear the combox box containing the list of scenegraph items
+        // Clear the combox box containing the list of scenegraph items
-	int ClearDisplayList(void);
+        int ClearDisplayList( void );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Fill in the default statistics
+        // Fill in the default statistics
-	int FillDefaultStatistics(void);
+        int FillDefaultStatistics( void );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Called by LoadAsset()
+        // Called by LoadAsset()
-	// reset the class instance to the default values
+        // reset the class instance to the default values
-	int Reset(void);
+        int Reset( void );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Replace the texture that is current selected with
+        // Replace the texture that is current selected with
-	// a new texture
+        // a new texture
-	int ReplaceCurrentTexture(const char* szPath);
+        int ReplaceCurrentTexture( const char* szPath );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Display the context menu (if there) for the specified tree item
+        // Display the context menu (if there) for the specified tree item
-	// hItem Valid tree view item handle
+        // hItem Valid tree view item handle
-	int ShowTreeViewContextMenu(HTREEITEM hItem);
+        int ShowTreeViewContextMenu( HTREEITEM hItem );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Event handling for pop-up menus displayed by th tree view
+        // Event handling for pop-up menus displayed by th tree view
-	int HandleTreeViewPopup(WPARAM wParam,LPARAM lParam);
+        int HandleTreeViewPopup( WPARAM wParam, LPARAM lParam );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Enable animation-related parts of the UI
+        // Enable animation-related parts of the UI
-	int EnableAnimTools(BOOL hm) ;
+        int EnableAnimTools( BOOL hm );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// setter for m_iViewMode
+        // setter for m_iViewMode
-	inline void SetViewMode(unsigned int p_iNew)
+        inline void SetViewMode( unsigned int p_iNew )
-	{
+        {
-		this->m_iViewMode = p_iNew;
+            this->m_iViewMode = p_iNew;
-	}
+        }
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// getter for m_iViewMode
+        // getter for m_iViewMode
-	inline unsigned int GetViewMode()
+        inline unsigned int GetViewMode()
-	{
+        {
-		return m_iViewMode;
+            return m_iViewMode;
-	}
+        }
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// change the texture view's zoom factor
+        // change the texture view's zoom factor
-	inline void SetTextureViewZoom(float f)
+        inline void SetTextureViewZoom( float f )
-	{
+        {
-		// FIX: Removed log(), seems to make more problems than it fixes
+            // FIX: Removed log(), seems to make more problems than it fixes
-		this->m_fTextureZoom += f* 15;
+            this->m_fTextureZoom += f * 15;
-		if (this->m_fTextureZoom < 0.05f)this->m_fTextureZoom = 0.05f;
+            if( this->m_fTextureZoom < 0.05f )this->m_fTextureZoom = 0.05f;
-	}
+        }
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// change the texture view's offset on the x axis
+        // change the texture view's offset on the x axis
-	inline void SetTextureViewOffsetX(float f)
+        inline void SetTextureViewOffsetX( float f )
-	{
+        {
-		this->m_vTextureOffset.x += f;
+            this->m_vTextureOffset.x += f;
-	}
+        }
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// change the texture view's offset on the y axis
+        // change the texture view's offset on the y axis
-	inline void SetTextureViewOffsetY(float f)
+        inline void SetTextureViewOffsetY( float f )
-	{
+        {
-		this->m_vTextureOffset.y += f;
+            this->m_vTextureOffset.y += f;
-	}
+        }
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// add a new texture to the list
+        // add a new texture to the list
-	inline void AddTexture(const TextureInfo& info)
+        inline void AddTexture( const TextureInfo& info )
-	{
+        {
-		this->m_asTextures.push_back(info);
+            this->m_asTextures.push_back( info );
-	}
+        }
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// add a new node to the list
+        // add a new node to the list
-	inline void AddNode(const NodeInfo& info)
+        inline void AddNode( const NodeInfo& info )
-	{
+        {
-		this->m_asNodes.push_back(info);
+            this->m_asNodes.push_back( info );
-	}
+        }
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// add a new mesh to the list
+        // add a new mesh to the list
-	inline void AddMesh(const MeshInfo& info)
+        inline void AddMesh( const MeshInfo& info )
-	{
+        {
-		this->m_asMeshes.push_back(info);
+            this->m_asMeshes.push_back( info );
-	}
+        }
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// add a new material to the list
+        // add a new material to the list
-	inline void AddMaterial(const MaterialInfo& info)
+        inline void AddMaterial( const MaterialInfo& info )
-	{
+        {
-		this->m_asMaterials.push_back(info);
+            this->m_asMaterials.push_back( info );
-	}
+        }
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// set the primary color of the checker pattern background
+        // set the primary color of the checker pattern background
-	inline void SetFirstCheckerColor(D3DXVECTOR4 c)
+        inline void SetFirstCheckerColor( D3DXVECTOR4 c )
-	{
+        {
-		this->m_avCheckerColors[0] = c;
+            this->m_avCheckerColors[ 0 ] = c;
-	}
+        }
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// set the secondary color of the checker pattern background
+        // set the secondary color of the checker pattern background
-	inline void SetSecondCheckerColor(D3DXVECTOR4 c)
+        inline void SetSecondCheckerColor( D3DXVECTOR4 c )
-	{
+        {
-		this->m_avCheckerColors[1] = c;
+            this->m_avCheckerColors[ 1 ] = c;
-	}
+        }
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// get the primary color of the checker pattern background
+        // get the primary color of the checker pattern background
-	inline const D3DXVECTOR4* GetFirstCheckerColor() const
+        inline const D3DXVECTOR4* GetFirstCheckerColor() const
-	{
+        {
-		return &this->m_avCheckerColors[0];
+            return &this->m_avCheckerColors[ 0 ];
-	}
+        }
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// get the secondary color of the checker pattern background
+        // get the secondary color of the checker pattern background
-	inline const D3DXVECTOR4* GetSecondCheckerColor() const
+        inline const D3DXVECTOR4* GetSecondCheckerColor() const
-	{
+        {
-		return &this->m_avCheckerColors[1];
+            return &this->m_avCheckerColors[ 1 ];
-	}
+        }
 
-private:
+    private:
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Render a screen-filling square using the checker pattern shader
+        // Render a screen-filling square using the checker pattern shader
-	int RenderPatternBG();
+        int RenderPatternBG();
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Render a given node in the scenegraph
+        // Render a given node in the scenegraph
-	// piNode Node to be rendered
+        // piNode Node to be rendered
-	// piMatrix Current transformation matrix
+        // piMatrix Current transformation matrix
-	// bAlpha Render alpha or opaque objects only?
+        // bAlpha Render alpha or opaque objects only?
-	int RenderNode (aiNode* piNode,const aiMatrix4x4& piMatrix,
+        int RenderNode( aiNode* piNode, const aiMatrix4x4& piMatrix,
-		bool bAlpha = false);
+            bool bAlpha = false );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Setup the camera for the stereo view rendering mode
+        // Setup the camera for the stereo view rendering mode
-	int SetupStereoView();
+        int SetupStereoView();
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Render the second view (for the right eye) in stereo mod
+        // Render the second view (for the right eye) in stereo mod
-	// m - World matrix
+        // m - World matrix
-	int RenderStereoView(const aiMatrix4x4& m);
+        int RenderStereoView( const aiMatrix4x4& m );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Handle user input
+        // Handle user input
-	int HandleInput();
+        int HandleInput();
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Handle user input for the texture viewer
+        // Handle user input for the texture viewer
-	int HandleInputTextureView();
+        int HandleInputTextureView();
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Handle user input if no asset is loaded
+        // Handle user input if no asset is loaded
-	int HandleInputEmptyScene();
+        int HandleInputEmptyScene();
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Draw the HUD (call only if FPS mode isn't active)
+        // Draw the HUD (call only if FPS mode isn't active)
-	int DrawHUD();
+        int DrawHUD();
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Used by OnSetup().
+        // Used by OnSetup().
-	// Do everything necessary to switch to texture view mode
+        // Do everything necessary to switch to texture view mode
-	int OnSetupTextureView(TextureInfo* pcNew);
+        int OnSetupTextureView( TextureInfo* pcNew );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Used by OnSetup().
+        // Used by OnSetup().
-	// Do everything necessary to switch to material view mode
+        // Do everything necessary to switch to material view mode
-	int OnSetupMaterialView(MaterialInfo* pcNew);
+        int OnSetupMaterialView( MaterialInfo* pcNew );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Used by OnSetup().
+        // Used by OnSetup().
-	// Do everything necessary to switch to node view mode
+        // Do everything necessary to switch to node view mode
-	int OnSetupNodeView(NodeInfo* pcNew);
+        int OnSetupNodeView( NodeInfo* pcNew );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Used by OnSetup().
+        // Used by OnSetup().
-	// Do everything necessary to switch back to normal view mode
+        // Do everything necessary to switch back to normal view mode
-	int OnSetupNormalView();
+        int OnSetupNormalView();
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Used by HandleTreeViewPopup().
+        // Used by HandleTreeViewPopup().
-	int HandleTreeViewPopup2(WPARAM wParam,LPARAM lParam);
+        int HandleTreeViewPopup2( WPARAM wParam, LPARAM lParam );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Render skeleton
+        // Render skeleton
-	int RenderSkeleton (aiNode* piNode,const aiMatrix4x4& piMatrix, 
+        int RenderSkeleton( aiNode* piNode, const aiMatrix4x4& piMatrix,
-		const aiMatrix4x4& parent);
+            const aiMatrix4x4& parent );
 
-	
 
-private:
 
-	// view mode
+    private:
-	unsigned int m_iViewMode;
 
-	// List of all textures in the display CB
+        // view mode
-	std::vector<TextureInfo> m_asTextures;
+        unsigned int m_iViewMode;
 
-	// current texture or NULL if no texture is active
+        // List of all textures in the display CB
-	TextureInfo* m_pcCurrentTexture;
+        std::vector<TextureInfo> m_asTextures;
 
-	// List of all node in the display CB
+        // current texture or NULL if no texture is active
-	std::vector<NodeInfo> m_asNodes;
+        TextureInfo* m_pcCurrentTexture;
 
-	// List of all node in the display CB
+        // List of all node in the display CB
-	std::vector<MeshInfo> m_asMeshes;
+        std::vector<NodeInfo> m_asNodes;
 
-	// current Node or NULL if no Node is active
+        // List of all node in the display CB
-	NodeInfo* m_pcCurrentNode;
+        std::vector<MeshInfo> m_asMeshes;
 
-	// List of all materials in the display CB
+        // current Node or NULL if no Node is active
-	std::vector<MaterialInfo> m_asMaterials;
+        NodeInfo* m_pcCurrentNode;
 
-	// current material or NULL if no material is active
+        // List of all materials in the display CB
-	MaterialInfo* m_pcCurrentMaterial;
+        std::vector<MaterialInfo> m_asMaterials;
 
-	// indices into the image list of the "display" tree view control
+        // current material or NULL if no material is active
-	unsigned int m_aiImageList[5]; /* = {0,1,2,3,4};*/
+        MaterialInfo* m_pcCurrentMaterial;
 
-	// Image list
+        // indices into the image list of the "display" tree view control
-	HIMAGELIST m_hImageList;
+        unsigned int m_aiImageList[ 5 ]; /* = {0,1,2,3,4};*/
 
-	// Root node of the tree, "Model"
+        // Image list
-	HTREEITEM m_hRoot;
+        HIMAGELIST m_hImageList;
 
-	// Current zoom factor of the texture viewer
+        // Root node of the tree, "Model"
-	float m_fTextureZoom;
+        HTREEITEM m_hRoot;
 
-	// Current offset (in pixels) of the texture viewer
+        // Current zoom factor of the texture viewer
-	aiVector2D m_vTextureOffset;
+        float m_fTextureZoom;
 
-	// Colors used to draw the checker pattern (for the
+        // Current offset (in pixels) of the texture viewer
-	// texture viewer as background )
+        aiVector2D m_vTextureOffset;
-	D3DXVECTOR4 m_avCheckerColors[2];
 
-	// View projection matrix
+        // Colors used to draw the checker pattern (for the
-	aiMatrix4x4 mViewProjection;
+        // texture viewer as background )
-	aiVector3D vPos;
+        D3DXVECTOR4 m_avCheckerColors[ 2 ];
-	};
 
+        // View projection matrix
+        aiMatrix4x4 mViewProjection;
+        aiVector3D vPos;
+    };
+
+}
 #endif // AV_DISPLAY_H_INCLUDE

tools/assimp_view/HelpDialog.cpp

@@ -39,14 +39,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-#include "stdafx.h"
 #include "assimp_view.h"
 
 #include "richedit.h"
 
 namespace AssimpView {
 
-
 //-------------------------------------------------------------------------------
 // Message procedure for the help dialog
 //-------------------------------------------------------------------------------

tools/assimp_view/Input.cpp

@@ -39,10 +39,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-#include "stdafx.h"
 #include "assimp_view.h"
 
-
 namespace AssimpView {
 
 //-------------------------------------------------------------------------------

tools/assimp_view/LogDisplay.cpp

@@ -39,14 +39,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-#include "stdafx.h"
 #include "assimp_view.h"
 
-
 namespace AssimpView {
 
-
+CLogDisplay CLogDisplay::s_cInstance;
-/* extern */ CLogDisplay CLogDisplay::s_cInstance;
 
 //-------------------------------------------------------------------------------
 void CLogDisplay::AddEntry(const std::string& szText,

tools/assimp_view/LogDisplay.h

@@ -38,59 +38,62 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
+#pragma once
 
-#if (!defined AV_LOG_DISPLAY_H_INCLUDED)
+#include <list>
-#define AV_LOG_DISPLAY_H_INCLUDE
 
-//-------------------------------------------------------------------------------
+namespace AssimpView
-/**	\brief Class to display log strings in the upper right corner of the view
+{
-*/
-//-------------------------------------------------------------------------------
-class CLogDisplay
-	{
-private:
 
-	CLogDisplay()  {}
+    //-------------------------------------------------------------------------------
+    /**	\brief Class to display log strings in the upper right corner of the view
+    */
+    //-------------------------------------------------------------------------------
+    class CLogDisplay
+    {
+    private:
 
-public:
+        CLogDisplay()  {}
 
-	// data structure for an entry in the log queue
+    public:
-	struct SEntry
-		{
-		SEntry ()
-			:
-			clrColor(D3DCOLOR_ARGB(0xFF,0xFF,0xFF,0x00)), dwStartTicks(0)
-				{}
 
-		std::string szText;
+        // data structure for an entry in the log queue
-		D3DCOLOR clrColor;
+        struct SEntry
-		DWORD dwStartTicks;
+        {
-		};
+            SEntry()
+                :
+                clrColor( D3DCOLOR_ARGB( 0xFF, 0xFF, 0xFF, 0x00 ) ), dwStartTicks( 0 )
+            {}
 
-	// Singleton accessors
+            std::string szText;
-	static CLogDisplay s_cInstance;
+            D3DCOLOR clrColor;
-	inline static CLogDisplay& Instance ()
+            DWORD dwStartTicks;
-		{
+        };
-		return s_cInstance;
-		}
 
-	// Add an entry to the log queue
+        // Singleton accessors
-	void AddEntry(const std::string& szText,
+        static CLogDisplay s_cInstance;
-		const D3DCOLOR clrColor = D3DCOLOR_ARGB(0xFF,0xFF,0xFF,0x00));
+        inline static CLogDisplay& Instance()
+        {
+            return s_cInstance;
+        }
 
-	// Release any native resources associated with the instance
+        // Add an entry to the log queue
-	void ReleaseNativeResource();
+        void AddEntry( const std::string& szText,
+            const D3DCOLOR clrColor = D3DCOLOR_ARGB( 0xFF, 0xFF, 0xFF, 0x00 ) );
 
-	// Recreate any native resources associated with the instance
+        // Release any native resources associated with the instance
-	void RecreateNativeResource();
+        void ReleaseNativeResource();
 
-	// Called during the render loop
+        // Recreate any native resources associated with the instance
-	void OnRender();
+        void RecreateNativeResource();
 
-private:
+        // Called during the render loop
+        void OnRender();
 
-	std::list<SEntry> asEntries;
+    private:
-	ID3DXFont* piFont;
-	};
 
-#endif // AV_LOG_DISPLAY_H_INCLUDE
+        std::list<SEntry> asEntries;
+        ID3DXFont* piFont;
+    };
+
+}

tools/assimp_view/LogWindow.cpp

@@ -39,13 +39,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-#include "stdafx.h"
 #include "assimp_view.h"
 #include "richedit.h"
 
 namespace AssimpView {
 
-/* extern */ CLogWindow CLogWindow::s_cInstance;
+CLogWindow CLogWindow::s_cInstance;
+
 extern HKEY g_hRegistry;
 
 // header for the RTF log file

tools/assimp_view/LogWindow.h

@@ -42,87 +42,92 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #if (!defined AV_LOG_WINDOW_H_INCLUDED)
 #define AV_LOG_WINDOW_H_INCLUDE
 
-
+namespace AssimpView
-//-------------------------------------------------------------------------------
-/**	\brief Subclass of Assimp::LogStream used to add all log messages to the
- *         log window.
-*/
-//-------------------------------------------------------------------------------
-class CMyLogStream : public Assimp::LogStream
 {
-public:
-	/**	@brief	Implementation of the abstract method	*/
-	void write(const char* message);
-};
 
 
-//-------------------------------------------------------------------------------
+    //-------------------------------------------------------------------------------
-/**	\brief Class to display log strings in a separate window
+    /**	\brief Subclass of Assimp::LogStream used to add all log messages to the
-*/
+     *         log window.
-//-------------------------------------------------------------------------------
+     */
-class CLogWindow
+    //-------------------------------------------------------------------------------
-	{
+    class CMyLogStream : public Assimp::LogStream
-private:
+    {
-
+    public:
-	friend class CMyLogStream;
+        /**	@brief	Implementation of the abstract method	*/
-	friend INT_PTR CALLBACK LogDialogProc(HWND hwndDlg,UINT uMsg,
+        void write( const char* message );
-		WPARAM wParam,LPARAM lParam);
+    };
-
-	CLogWindow() : hwnd(NULL),  bIsVisible(false), bUpdate(true) {}
-
-public:
 
 
-	// Singleton accessors
+    //-------------------------------------------------------------------------------
-	static CLogWindow s_cInstance;
+    /**	\brief Class to display log strings in a separate window
-	inline static CLogWindow& Instance ()
+    */
-		{
+    //-------------------------------------------------------------------------------
-		return s_cInstance;
+    class CLogWindow
-		}
+    {
+    private:
 
-	// initializes the log window
+        friend class CMyLogStream;
-	void Init ();
+        friend INT_PTR CALLBACK LogDialogProc( HWND hwndDlg, UINT uMsg,
+            WPARAM wParam, LPARAM lParam );
 
-	// Shows the log window
+        CLogWindow() : hwnd( NULL ), bIsVisible( false ), bUpdate( true ) {}
-	void Show();
 
-	// Clears the log window
+    public:
-	void Clear();
-
-	// Save the log window to an user-defined file
-	void Save();
-
-	// write a line to the log window
-	void WriteLine(const char* message);
-
-	// Set the bUpdate member
-	inline void SetAutoUpdate(bool b)
-	{
-		this->bUpdate = b;
-	}
-
-	// updates the log file
-	void Update();
-
-private:
-
-	// Window handle
-	HWND hwnd;
-
-	// current text of the window (contains RTF tags)
-	std::string szText;
-	std::string szPlainText;
-
-	// is the log window currently visible?
-	bool bIsVisible;
-
-	// Specified whether each new log message updates the log automatically
-	bool bUpdate;
 
 
-public:
+        // Singleton accessors
-	// associated log stream
+        static CLogWindow s_cInstance;
-	CMyLogStream* pcStream;
+        inline static CLogWindow& Instance()
-	};
+        {
+            return s_cInstance;
+        }
+
+        // initializes the log window
+        void Init();
+
+        // Shows the log window
+        void Show();
+
+        // Clears the log window
+        void Clear();
+
+        // Save the log window to an user-defined file
+        void Save();
+
+        // write a line to the log window
+        void WriteLine( const char* message );
+
+        // Set the bUpdate member
+        inline void SetAutoUpdate( bool b )
+        {
+            this->bUpdate = b;
+        }
+
+        // updates the log file
+        void Update();
+
+    private:
+
+        // Window handle
+        HWND hwnd;
+
+        // current text of the window (contains RTF tags)
+        std::string szText;
+        std::string szPlainText;
+
+        // is the log window currently visible?
+        bool bIsVisible;
+
+        // Specified whether each new log message updates the log automatically
+        bool bUpdate;
+
+
+    public:
+        // associated log stream
+        CMyLogStream* pcStream;
+    };
+
+}
 
 #endif // AV_LOG_DISPLA

tools/assimp_view/MaterialManager.h

@@ -39,164 +39,170 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-#if (!defined AV_MATERIAL_H_INCLUDED)
+#pragma once
-#define AV_MATERIAL_H_INCLUDE
 
-//-------------------------------------------------------------------------------
+#include <map>
-/* Helper class to create, access and destroy materials
+
-*/
+#include "AssetHelper.h"
-//-------------------------------------------------------------------------------
+
-class CMaterialManager
+namespace AssimpView
 {
-private:
 
-	friend class CDisplay;
+    //-------------------------------------------------------------------------------
+    /* Helper class to create, access and destroy materials
+    */
+    //-------------------------------------------------------------------------------
+    class CMaterialManager
+    {
+    private:
 
-	// default constructor
+        friend class CDisplay;
-	CMaterialManager() 
-		:	m_iShaderCount (0), sDefaultTexture() {}
 
-	~CMaterialManager() {
+        // default constructor
-		if (sDefaultTexture) {
+        CMaterialManager()
-			sDefaultTexture->Release();
+            : m_iShaderCount( 0 ), sDefaultTexture() {}
-		}
-		Reset();
-	}
 
-public:
+        ~CMaterialManager() {
+            if( sDefaultTexture ) {
+                sDefaultTexture->Release();
+            }
+            Reset();
+        }
 
-	//------------------------------------------------------------------
+    public:
-	// Singleton accessors
-	static CMaterialManager s_cInstance;
-	inline static CMaterialManager& Instance ()
-		{
-		return s_cInstance;
-		}
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Delete all resources of a given material
+        // Singleton accessors
-	//
+        static CMaterialManager s_cInstance;
-	// Must be called before CreateMaterial() to prevent memory leaking
+        inline static CMaterialManager& Instance()
-	void DeleteMaterial(AssetHelper::MeshHelper* pcIn);
+        {
-	
+            return s_cInstance;
-	//------------------------------------------------------------------
+        }
-	// Create the material for a mesh.
-	//
-	// The function checks whether an identical shader is already in use.
-	// A shader is considered to be identical if it has the same input 
-	// signature and takes the same number of texture channels.
-	int CreateMaterial(AssetHelper::MeshHelper* pcMesh,
-		const aiMesh* pcSource);
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Setup the material for a given mesh
+        // Delete all resources of a given material
-	// pcMesh Mesh to be rendered
+        //
-	// pcProj Projection matrix
+        // Must be called before CreateMaterial() to prevent memory leaking
-	// aiMe Current world matrix
+        void DeleteMaterial( AssetHelper::MeshHelper* pcIn );
-	// pcCam Camera matrix
-	// vPos Position of the camera
-	// TODO: Extract camera position from matrix ...
-	//
-	int SetupMaterial (AssetHelper::MeshHelper* pcMesh,
-		const aiMatrix4x4& pcProj,
-		const aiMatrix4x4& aiMe,
-		const aiMatrix4x4& pcCam,
-		const aiVector3D& vPos);
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// End the material for a given mesh
+        // Create the material for a mesh.
-	// Called after mesh rendering is complete
+        //
-	// pcMesh Mesh object
+        // The function checks whether an identical shader is already in use.
-	int EndMaterial (AssetHelper::MeshHelper* pcMesh);
+        // A shader is considered to be identical if it has the same input 
+        // signature and takes the same number of texture channels.
+        int CreateMaterial( AssetHelper::MeshHelper* pcMesh,
+            const aiMesh* pcSource );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Recreate all specular materials depending on the current 
+        // Setup the material for a given mesh
-	// specularity settings
+        // pcMesh Mesh to be rendered
-	//
+        // pcProj Projection matrix
-	// Diffuse-only materials are ignored.
+        // aiMe Current world matrix
-	// Must be called after specular highlights have been toggled
+        // pcCam Camera matrix
-	int UpdateSpecularMaterials();
+        // vPos Position of the camera
+        // TODO: Extract camera position from matrix ...
+        //
+        int SetupMaterial( AssetHelper::MeshHelper* pcMesh,
+            const aiMatrix4x4& pcProj,
+            const aiMatrix4x4& aiMe,
+            const aiMatrix4x4& pcCam,
+            const aiVector3D& vPos );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// find a valid path to a texture file
+        // End the material for a given mesh
-	//
+        // Called after mesh rendering is complete
-	// Handle 8.3 syntax correctly, search the environment of the
+        // pcMesh Mesh object
-	// executable and the asset for a texture with a name very similar 
+        int EndMaterial( AssetHelper::MeshHelper* pcMesh );
-	// to a given one
-	int FindValidPath(aiString* p_szString);
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Load a texture into memory and create a native D3D texture resource
+        // Recreate all specular materials depending on the current 
-	//
+        // specularity settings
-	// The function tries to find a valid path for a texture
+        //
-	int LoadTexture(IDirect3DTexture9** p_ppiOut,aiString* szPath);
+        // Diffuse-only materials are ignored.
+        // Must be called after specular highlights have been toggled
+        int UpdateSpecularMaterials();
+
+        //------------------------------------------------------------------
+        // find a valid path to a texture file
+        //
+        // Handle 8.3 syntax correctly, search the environment of the
+        // executable and the asset for a texture with a name very similar 
+        // to a given one
+        int FindValidPath( aiString* p_szString );
+
+        //------------------------------------------------------------------
+        // Load a texture into memory and create a native D3D texture resource
+        //
+        // The function tries to find a valid path for a texture
+        int LoadTexture( IDirect3DTexture9** p_ppiOut, aiString* szPath );
 
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Getter for m_iShaderCount
+        // Getter for m_iShaderCount
-	//
+        //
-	inline unsigned int GetShaderCount()
+        inline unsigned int GetShaderCount()
-	{
+        {
-		return this->m_iShaderCount;
+            return this->m_iShaderCount;
-	}
+        }
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Reset the state of the class
+        // Reset the state of the class
-	// Called whenever a new asset is loaded
+        // Called whenever a new asset is loaded
-	inline void Reset()
+        inline void Reset()
-	{
+        {
-		this->m_iShaderCount = 0;
+            this->m_iShaderCount = 0;
-		for (TextureCache::iterator it = sCachedTextures.begin(); it != sCachedTextures.end(); ++it) {
+            for( TextureCache::iterator it = sCachedTextures.begin(); it != sCachedTextures.end(); ++it ) {
-			(*it).second->Release();
+                ( *it ).second->Release();
-		}
+            }
-		sCachedTextures.clear();
+            sCachedTextures.clear();
-	}
+        }
 
-private:
+    private:
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// find a valid path to a texture file
+        // find a valid path to a texture file
-	//
+        //
-	// Handle 8.3 syntax correctly, search the environment of the
+        // Handle 8.3 syntax correctly, search the environment of the
-	// executable and the asset for a texture with a name very similar 
+        // executable and the asset for a texture with a name very similar 
-	// to a given one
+        // to a given one
-	bool TryLongerPath(char* szTemp,aiString* p_szString);
+        bool TryLongerPath( char* szTemp, aiString* p_szString );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Setup the default texture for a texture channel
+        // Setup the default texture for a texture channel
-	//
+        //
-	// Generates a default checker pattern for a texture
+        // Generates a default checker pattern for a texture
-	int SetDefaultTexture(IDirect3DTexture9** p_ppiOut);
+        int SetDefaultTexture( IDirect3DTexture9** p_ppiOut );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Convert a height map to a normal map if necessary
+        // Convert a height map to a normal map if necessary
-	//
+        //
-	// The function tries to detect the type of a texture automatically.
+        // The function tries to detect the type of a texture automatically.
-	// However, this wont work in every case.
+        // However, this wont work in every case.
-	void HMtoNMIfNecessary(IDirect3DTexture9* piTexture,
+        void HMtoNMIfNecessary( IDirect3DTexture9* piTexture,
-		IDirect3DTexture9** piTextureOut,
+            IDirect3DTexture9** piTextureOut,
-		bool bWasOriginallyHM = true);
+            bool bWasOriginallyHM = true );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Search for non-opaque pixels in a texture
+        // Search for non-opaque pixels in a texture
-	//
+        //
-	// A pixel is considered to be non-opaque if its alpha value is
+        // A pixel is considered to be non-opaque if its alpha value is
-	// less than 255
+        // less than 255
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	bool HasAlphaPixels(IDirect3DTexture9* piTexture);
+        bool HasAlphaPixels( IDirect3DTexture9* piTexture );
 
-private:
+    private:
 
-	//
+        //
-	// Specifies the number of different shaders generated for
+        // Specifies the number of different shaders generated for
-	// the current asset. This number is incremented by CreateMaterial()
+        // the current asset. This number is incremented by CreateMaterial()
-	// each time a shader isn't found in cache and needs to be created
+        // each time a shader isn't found in cache and needs to be created
-	//
+        //
-	unsigned int m_iShaderCount;
+        unsigned int m_iShaderCount;
-	IDirect3DTexture9* sDefaultTexture;
+        IDirect3DTexture9* sDefaultTexture;
 
-	typedef std::map<std::string,IDirect3DTexture9*> TextureCache;
+        typedef std::map<std::string, IDirect3DTexture9*> TextureCache;
-	TextureCache sCachedTextures;
+        TextureCache sCachedTextures;
-};
+    };
 
-#endif //!! include guard
+}

tools/assimp_view/MeshRenderer.cpp

@@ -39,7 +39,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-#include "stdafx.h"
 #include "assimp_view.h"
 
 #include <map>
@@ -47,7 +46,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace AssimpView {
 
-
 CMeshRenderer CMeshRenderer::s_cInstance;
 
 //-------------------------------------------------------------------------------

tools/assimp_view/MeshRenderer.h

@@ -42,56 +42,58 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #if (!defined AV_MESH_RENDERER_H_INCLUDED)
 #define AV_MESH_RENDERER_H_INCLUDED
 
+namespace AssimpView {
 
 
-//-------------------------------------------------------------------------------
+    //-------------------------------------------------------------------------------
-/* Helper class tp render meshes
+    /* Helper class tp render meshes
-*/
+    */
-//-------------------------------------------------------------------------------
+    //-------------------------------------------------------------------------------
-class CMeshRenderer
+    class CMeshRenderer
-{
+    {
-private:
+    private:
 
-	// default constructor
+        // default constructor
-	CMeshRenderer() 
+        CMeshRenderer()
 
-	{
+        {
-		// no other members to initialize
+            // no other members to initialize
-	}
+        }
 
-public:
+    public:
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Singleton accessors
+        // Singleton accessors
-	static CMeshRenderer s_cInstance;
+        static CMeshRenderer s_cInstance;
-	inline static CMeshRenderer& Instance ()
+        inline static CMeshRenderer& Instance()
-	{
+        {
-		return s_cInstance;
+            return s_cInstance;
-	}
+        }
 
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Draw a mesh in the global mesh list using the current pipeline state
+        // Draw a mesh in the global mesh list using the current pipeline state
-	// iIndex Index of the mesh to be drawn
+        // iIndex Index of the mesh to be drawn
-	//
+        //
-	// The function draws all faces in order, regardless of their distance
+        // The function draws all faces in order, regardless of their distance
-	int DrawUnsorted(unsigned int iIndex);
+        int DrawUnsorted( unsigned int iIndex );
 
-	//------------------------------------------------------------------
+        //------------------------------------------------------------------
-	// Draw a mesh in the global mesh list using the current pipeline state
+        // Draw a mesh in the global mesh list using the current pipeline state
-	// iIndex Index of the mesh to be drawn
+        // iIndex Index of the mesh to be drawn
-	//
+        //
-	// The method sorts all vertices by their distance (back to front)
+        // The method sorts all vertices by their distance (back to front)
-	//
+        //
-	// mWorld World matrix for the node
+        // mWorld World matrix for the node
-	int DrawSorted(unsigned int iIndex,
+        int DrawSorted( unsigned int iIndex,
-		const aiMatrix4x4& mWorld);
+            const aiMatrix4x4& mWorld );
 
 
 
-private:
+    private:
 
-	
-};
 
+    };
+
+}
 #endif //!! include guard

tools/assimp_view/MessageProc.cpp

@@ -39,12 +39,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-#include "stdafx.h"
 #include "assimp_view.h"
+#include <assimp/Exporter.hpp>
+#include <algorithm>
+
 #include <windowsx.h>
 
 namespace AssimpView {
 
+using namespace Assimp;
+
 // Static array to keep custom color values
 COLORREF g_aclCustomColors[16] = {0};
 
@@ -1044,9 +1048,9 @@ void DoExport(size_t formatId)
 		ai_assert(strlen(szFileName) <= MAX_PATH);
 
 		// invent a nice default file name 
-		char* sz = std::max(strrchr(szFileName,'\\'),strrchr(szFileName,'/'));
+		char* sz = max(strrchr(szFileName,'\\'),strrchr(szFileName,'/'));
 		if (sz) {
-			strncpy(sz,std::max(strrchr(g_szFileName,'\\'),strrchr(g_szFileName,'/')),MAX_PATH);
+			strncpy(sz,max(strrchr(g_szFileName,'\\'),strrchr(g_szFileName,'/')),MAX_PATH);
 		}
 	}
 	else {

tools/assimp_view/Normals.cpp

@@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 
-#include "stdafx.h"
 #include "assimp_view.h"
 
 // note: these are no longer part of the public API, but they are 
@@ -53,6 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace AssimpView {
 
+using namespace Assimp;
 
 bool g_bWasFlipped = false;
 float g_smoothAngle = 80.f;

tools/assimp_view/SceneAnimator.cpp

@@ -43,7 +43,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the utility class SceneAnimator
  */
 
-#include "stdafx.h"
 #include "assimp_view.h"
 
 using namespace AssimpView;

tools/assimp_view/assimp_view.h

@@ -47,6 +47,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // include resource definitions
 #include "resource.h"
 
+#include <assert.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <memory.h>
+#include <tchar.h>
+#include <stdio.h>
+#include <time.h>
+
 // Include ASSIMP headers (XXX: do we really need all of them?)
 #include <assimp/cimport.h>
 #include <assimp/Importer.hpp>
@@ -59,17 +67,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/LogStream.hpp>
 #include <assimp/DefaultLogger.hpp>
 
-#include "../../code/AssimpPCH.h" /* HACK */
  
 #include "../../code/MaterialSystem.h"   // aiMaterial class
 #include "../../code/StringComparison.h" // ASSIMP_stricmp and ASSIMP_strincmp
 
 // in order for std::min and std::max to behave properly
-#ifdef min 
+#ifndef max
-#undef min
+#define max(a,b)            (((a) > (b)) ? (a) : (b))
-#endif // min
+#endif // max
-#ifdef max 
+#ifndef min
-#undef max
+#define min(a,b)            (((a) < (b)) ? (a) : (b))
 #endif // min
 
 #include <time.h>
@@ -77,11 +84,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // default movement speed 
 #define MOVE_SPEED 3.f
 
-using namespace Assimp;
-
-namespace AssimpView 
-{
-
 #include "AssetHelper.h"
 #include "Camera.h"
 #include "RenderOptions.h"
@@ -93,7 +95,6 @@ namespace AssimpView
 #include "MeshRenderer.h"
 #include "MaterialManager.h"
 
-} // end of namespace AssimpView - for a while
 
 // outside of namespace, to help Intellisense and solve boost::metatype_stuff_miracle
 #include "AnimEvaluator.h"
@@ -105,30 +106,30 @@ namespace AssimpView
 //-------------------------------------------------------------------------------
 // Function prototypes
 //-------------------------------------------------------------------------------
-	int InitD3D(void);
+int InitD3D(void);
-	int ShutdownD3D(void);
+int ShutdownD3D(void);
-	int CreateDevice (bool p_bMultiSample,bool p_bSuperSample, bool bHW = true);
+int CreateDevice (bool p_bMultiSample,bool p_bSuperSample, bool bHW = true);
-	int CreateDevice (void);
+int CreateDevice (void);
-	int ShutdownDevice(void);
+int ShutdownDevice(void);
-	int GetProjectionMatrix (aiMatrix4x4& p_mOut);
+int GetProjectionMatrix (aiMatrix4x4& p_mOut);
-	int LoadAsset(void);
+int LoadAsset(void);
-	int CreateAssetData(void);
+int CreateAssetData(void);
-	int DeleteAssetData(bool bNoMaterials = false);
+int DeleteAssetData(bool bNoMaterials = false);
-	int ScaleAsset(void);
+int ScaleAsset(void);
-	int DeleteAsset(void);
+int DeleteAsset(void);
-	int SetupFPSView();
+int SetupFPSView();
 	
-	aiVector3D GetCameraMatrix (aiMatrix4x4& p_mOut);
+aiVector3D GetCameraMatrix (aiMatrix4x4& p_mOut);
-	int CreateMaterial(AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSource);
+int CreateMaterial(AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSource);
 
-	void HandleMouseInputFPS( void );
+void HandleMouseInputFPS( void );
-	void HandleMouseInputLightRotate( void );
+void HandleMouseInputLightRotate( void );
-	void HandleMouseInputLocal( void );
+void HandleMouseInputLocal( void );
-	void HandleKeyboardInputFPS( void );
+void HandleKeyboardInputFPS( void );
-	void HandleMouseInputLightIntensityAndColor( void );
+void HandleMouseInputLightIntensityAndColor( void );
-	void HandleMouseInputSkyBox( void );
+void HandleMouseInputSkyBox( void );
-	void HandleKeyboardInputTextureView( void );
+void HandleKeyboardInputTextureView( void );
-	void HandleMouseInputTextureView( void );
+void HandleMouseInputTextureView( void );
 
 
 //-------------------------------------------------------------------------------
@@ -160,7 +161,7 @@ INT_PTR CALLBACK AboutMessageProc(HWND hwndDlg,UINT uMsg,
 
 //-------------------------------------------------------------------------------
 // 
-// Dialog prcoedure for the help dialog
+// Dialog procedure for the help dialog
 //
 //-------------------------------------------------------------------------------
 INT_PTR CALLBACK HelpDialogProc(HWND hwndDlg,UINT uMsg,
@@ -182,7 +183,7 @@ type clamp(intype in)
 {
 	// for unsigned types only ...
 	intype mask = (0x1u << (sizeof(type)*8))-1;
-	return (type)std::max((intype)0,std::min(in,mask));
+	return (type)max((intype)0,min(in,mask));
 }
 
 

workspaces/xcode3/assimp.xcodeproj/project.pbxproj

@@ -117,11 +117,11 @@
 		2B7F478E1708365200A106A9 /* tuple.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45961708365100A106A9 /* tuple.hpp */; };
 		2B7F478F1708365200A106A9 /* tuple.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45961708365100A106A9 /* tuple.hpp */; };
 		2B7F47901708365200A106A9 /* tuple.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45961708365100A106A9 /* tuple.hpp */; };
-		2B7F479B1708365200A106A9 /* ByteSwap.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwap.h */; };
+		2B7F479B1708365200A106A9 /* ByteSwapper.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwapper.h */; };
-		2B7F479C1708365200A106A9 /* ByteSwap.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwap.h */; };
+		2B7F479C1708365200A106A9 /* ByteSwapper.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwapper.h */; };
-		2B7F479D1708365200A106A9 /* ByteSwap.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwap.h */; };
+		2B7F479D1708365200A106A9 /* ByteSwapper.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwapper.h */; };
-		2B7F479E1708365200A106A9 /* ByteSwap.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwap.h */; };
+		2B7F479E1708365200A106A9 /* ByteSwapper.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwapper.h */; };
-		2B7F479F1708365200A106A9 /* ByteSwap.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwap.h */; };
+		2B7F479F1708365200A106A9 /* ByteSwapper.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwapper.h */; };
 		2B7F47A01708365200A106A9 /* CalcTangentsProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B7F459A1708365100A106A9 /* CalcTangentsProcess.cpp */; };
 		2B7F47A11708365200A106A9 /* CalcTangentsProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B7F459A1708365100A106A9 /* CalcTangentsProcess.cpp */; };
 		2B7F47A21708365200A106A9 /* CalcTangentsProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B7F459A1708365100A106A9 /* CalcTangentsProcess.cpp */; };
@@ -2018,7 +2018,7 @@
 		2B7F45931708365100A106A9 /* static_assert.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = static_assert.hpp; sourceTree = "<group>"; };
 		2B7F45941708365100A106A9 /* timer.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = timer.hpp; sourceTree = "<group>"; };
 		2B7F45961708365100A106A9 /* tuple.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = tuple.hpp; sourceTree = "<group>"; };
-		2B7F45991708365100A106A9 /* ByteSwap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ByteSwap.h; sourceTree = "<group>"; };
+		2B7F45991708365100A106A9 /* ByteSwapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ByteSwapper.h; sourceTree = "<group>"; };
 		2B7F459A1708365100A106A9 /* CalcTangentsProcess.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CalcTangentsProcess.cpp; sourceTree = "<group>"; };
 		2B7F459B1708365100A106A9 /* CalcTangentsProcess.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CalcTangentsProcess.h; sourceTree = "<group>"; };
 		2B7F459C1708365100A106A9 /* CInterfaceIOWrapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CInterfaceIOWrapper.h; sourceTree = "<group>"; };
@@ -2509,7 +2509,7 @@
 				2B7F45761708365100A106A9 /* BaseProcess.cpp */,
 				2B7F45771708365100A106A9 /* BaseProcess.h */,
 				2B7F45831708365100A106A9 /* BlobIOSystem.h */,
-				2B7F45991708365100A106A9 /* ByteSwap.h */,
+				2B7F45991708365100A106A9 /* ByteSwapper.h */,
 				2B7F459A1708365100A106A9 /* CalcTangentsProcess.cpp */,
 				2B7F459B1708365100A106A9 /* CalcTangentsProcess.h */,
 				2B7F459C1708365100A106A9 /* CInterfaceIOWrapper.h */,
@@ -3517,7 +3517,7 @@
 				2B7F47841708365200A106A9 /* static_assert.hpp in Headers */,
 				2B7F47891708365200A106A9 /* timer.hpp in Headers */,
 				2B7F478E1708365200A106A9 /* tuple.hpp in Headers */,
-				2B7F479D1708365200A106A9 /* ByteSwap.h in Headers */,
+				2B7F479D1708365200A106A9 /* ByteSwapper.h in Headers */,
 				2B7F47A71708365200A106A9 /* CalcTangentsProcess.h in Headers */,
 				2B7F47AC1708365200A106A9 /* CInterfaceIOWrapper.h in Headers */,
 				2B7F47C51708365200A106A9 /* ColladaExporter.h in Headers */,
@@ -3765,7 +3765,7 @@
 				2B7F47851708365200A106A9 /* static_assert.hpp in Headers */,
 				2B7F478A1708365200A106A9 /* timer.hpp in Headers */,
 				2B7F478F1708365200A106A9 /* tuple.hpp in Headers */,
-				2B7F479E1708365200A106A9 /* ByteSwap.h in Headers */,
+				2B7F479E1708365200A106A9 /* ByteSwapper.h in Headers */,
 				2B7F47A81708365200A106A9 /* CalcTangentsProcess.h in Headers */,
 				2B7F47AD1708365200A106A9 /* CInterfaceIOWrapper.h in Headers */,
 				2B7F47C61708365200A106A9 /* ColladaExporter.h in Headers */,
@@ -4013,7 +4013,7 @@
 				2B7F47861708365200A106A9 /* static_assert.hpp in Headers */,
 				2B7F478B1708365200A106A9 /* timer.hpp in Headers */,
 				2B7F47901708365200A106A9 /* tuple.hpp in Headers */,
-				2B7F479F1708365200A106A9 /* ByteSwap.h in Headers */,
+				2B7F479F1708365200A106A9 /* ByteSwapper.h in Headers */,
 				2B7F47A91708365200A106A9 /* CalcTangentsProcess.h in Headers */,
 				2B7F47AE1708365200A106A9 /* CInterfaceIOWrapper.h in Headers */,
 				2B7F47C71708365200A106A9 /* ColladaExporter.h in Headers */,
@@ -4261,7 +4261,7 @@
 				2B7F47821708365200A106A9 /* static_assert.hpp in Headers */,
 				2B7F47871708365200A106A9 /* timer.hpp in Headers */,
 				2B7F478C1708365200A106A9 /* tuple.hpp in Headers */,
-				2B7F479B1708365200A106A9 /* ByteSwap.h in Headers */,
+				2B7F479B1708365200A106A9 /* ByteSwapper.h in Headers */,
 				2B7F47A51708365200A106A9 /* CalcTangentsProcess.h in Headers */,
 				2B7F47AA1708365200A106A9 /* CInterfaceIOWrapper.h in Headers */,
 				2B7F47C31708365200A106A9 /* ColladaExporter.h in Headers */,
@@ -4509,7 +4509,7 @@
 				2B7F47831708365200A106A9 /* static_assert.hpp in Headers */,
 				2B7F47881708365200A106A9 /* timer.hpp in Headers */,
 				2B7F478D1708365200A106A9 /* tuple.hpp in Headers */,
-				2B7F479C1708365200A106A9 /* ByteSwap.h in Headers */,
+				2B7F479C1708365200A106A9 /* ByteSwapper.h in Headers */,
 				2B7F47A61708365200A106A9 /* CalcTangentsProcess.h in Headers */,
 				2B7F47AB1708365200A106A9 /* CInterfaceIOWrapper.h in Headers */,
 				2B7F47C41708365200A106A9 /* ColladaExporter.h in Headers */,