Merge pull request #6 from assimp/master

Update Fork

.travis.yml

@@ -40,7 +40,6 @@ script:
     cd ../regression ;
     chmod 755 run.py ;
     ./run.py ;
-    echo "==========================================================" ;
+    chmod 755 result_checker.py ;
-    echo "REGRESSION TEST FAILURES (results/run_regression_suite_failures.csv)" ;
+    ./result_checker.py;
-    cat ../results/run_regression_suite_failures.csv;
     fi

CMakeLists.txt

@@ -5,7 +5,7 @@ PROJECT( Assimp )
 option(BUILD_SHARED_LIBS "Build package with shared libraries." ON)
 if(NOT BUILD_SHARED_LIBS)
         #set(CMAKE_EXE_LINKER_FLAGS "-static")
-	set(LINK_SEARCH_START_STATIC TRUE)
+    set(LINK_SEARCH_START_STATIC TRUE)
 endif(NOT BUILD_SHARED_LIBS)
 
 # Define here the needed parameters
@@ -23,7 +23,7 @@ add_definitions( -DOPENDDL_NO_USE_CPP11 )
 # Get the current working branch
 execute_process(
     COMMAND git rev-parse --abbrev-ref HEAD
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
     OUTPUT_VARIABLE GIT_BRANCH
     OUTPUT_STRIP_TRAILING_WHITESPACE
 )
@@ -31,7 +31,7 @@ execute_process(
 # Get the latest abbreviated commit hash of the working branch
 execute_process(
     COMMAND git log -1 --format=%h
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
     OUTPUT_VARIABLE GIT_COMMIT_HASH
     OUTPUT_STRIP_TRAILING_WHITESPACE
 )
@@ -62,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)
-    set(CMAKE_CXX_FLAGS "-fPIC") # this is a very important switch and some libraries seem now to have it....
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC") # this is a very important switch and some libraries seem now to have it....
     # hide all not-exported symbols
-    set(CMAKE_CXX_FLAGS "-fvisibility=hidden -Wall" )
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -Wall" )
 elseif(MSVC)
     # enable multi-core compilation with MSVC
     add_definitions(/MP)
@@ -191,46 +191,46 @@ MARK_AS_ADVANCED ( ASSIMP_BUILD_ARCHITECTURE ASSIMP_BUILD_COMPILER )
 
 
 SET ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER OFF CACHE BOOL
-	"Build the C4D importer, which relies on the non-free Melange SDK." 
+    "Build the C4D importer, which relies on the non-free Melange SDK." 
 )
 
 IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
-	IF ( MSVC )
+    IF ( MSVC )
-		SET(C4D_INCLUDES "${CMAKE_CURRENT_SOURCE_DIR}/contrib/Melange/_melange/includes")
+        SET(C4D_INCLUDES "${CMAKE_CURRENT_SOURCE_DIR}/contrib/Melange/_melange/includes")
         
-		# pick the correct prebuilt library
+        # pick the correct prebuilt library
-		IF(MSVC11)
+        IF(MSVC11)
-			SET(C4D_LIB_POSTFIX "_2012md")
+            SET(C4D_LIB_POSTFIX "_2012md")
-		ELSEIF(MSVC10)
+        ELSEIF(MSVC10)
-			SET(C4D_LIB_POSTFIX "_2010md")
+            SET(C4D_LIB_POSTFIX "_2010md")
-		ELSEIF(MSVC90)
+        ELSEIF(MSVC90)
-			SET(C4D_LIB_POSTFIX "_2008md")
+            SET(C4D_LIB_POSTFIX "_2008md")
-		ELSE()
+        ELSE()
-			MESSAGE( FATAL_ERROR 
+            MESSAGE( FATAL_ERROR 
-				"C4D is currently only supported with MSVC 9, 10, 11"
+                "C4D is currently only supported with MSVC 9, 10, 11"
-			)
+            )
-		ENDIF()
+        ENDIF()
         
-		IF(CMAKE_CL_64)
+        IF(CMAKE_CL_64)
-			SET(C4D_LIB_ARCH_POSTFIX "_x64")
+            SET(C4D_LIB_ARCH_POSTFIX "_x64")
-		ELSE()
+        ELSE()
-			SET(C4D_LIB_ARCH_POSTFIX "")
+            SET(C4D_LIB_ARCH_POSTFIX "")
-		ENDIF()
+        ENDIF()
         
-		SET(C4D_LIB_BASE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/contrib/Melange/_melange/lib/WIN")
+        SET(C4D_LIB_BASE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/contrib/Melange/_melange/lib/WIN")
         
-		SET(C4D_DEBUG_LIBRARY "${C4D_LIB_BASE_PATH}/debug/_melange_lib${C4D_LIB_ARCH_POSTFIX}${C4D_LIB_POSTFIX}.lib")
+        SET(C4D_DEBUG_LIBRARY "${C4D_LIB_BASE_PATH}/debug/_melange_lib${C4D_LIB_ARCH_POSTFIX}${C4D_LIB_POSTFIX}.lib")
-		SET(C4D_RELEASE_LIBRARY "${C4D_LIB_BASE_PATH}/release/_melange_lib${C4D_LIB_ARCH_POSTFIX}${C4D_LIB_POSTFIX}.lib")
+        SET(C4D_RELEASE_LIBRARY "${C4D_LIB_BASE_PATH}/release/_melange_lib${C4D_LIB_ARCH_POSTFIX}${C4D_LIB_POSTFIX}.lib")
         
-		# winsock and winmm are necessary dependencies of melange (this is undocumented, but true.)
+        # winsock and winmm are necessary dependencies of melange (this is undocumented, but true.)
-		SET(C4D_EXTRA_LIBRARIES WSock32.lib Winmm.lib)
+        SET(C4D_EXTRA_LIBRARIES WSock32.lib Winmm.lib)
-	ELSE ()
+    ELSE ()
-		MESSAGE( FATAL_ERROR 
+        MESSAGE( FATAL_ERROR 
-			"C4D is currently only available on Windows with melange SDK installed in contrib/Melange"
+            "C4D is currently only available on Windows with melange SDK installed in contrib/Melange"
-		)
+        )
-	ENDIF ( MSVC )
+    ENDIF ( MSVC )
 else (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
-	ADD_DEFINITIONS( -DASSIMP_BUILD_NO_C4D_IMPORTER )
+    ADD_DEFINITIONS( -DASSIMP_BUILD_NO_C4D_IMPORTER )
 ENDIF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
 
 

CodeConventions.md

@@ -0,0 +1,12 @@
+
+Open Asset Import Library Coding Conventions
+==
+
+If you want to participate as a developer in the **Open Asset Import Library** please read and respect the following coding conventions. This will ensure consistency throughout the codebase and help all the Open Asset Import Library users.
+
+Spacing
+==
+
+* Use UNIX-style line endings (LF)
+* Remove any trailing whitespace
+* Expand tabs to 4 spaces

CodeConventions.txt

@@ -1,14 +0,0 @@
-       ===============================================
-        The Asset-Importer-Library Coding conventions
-       ===============================================
-
-	If you want to participate to the Asset-Importer_Library please have a look
-	onto these coding conventions and try to follow them. They are more or less
-	some kind of guide line to help others coming into the code and help all
-	the Asset-Importer-Library users.
-	
-	 Tab width
-	===========
-	The tab width shall be 4 spaces.
-	
-	

cmake-modules/AddGTest.cmake

@@ -30,35 +30,43 @@ endif()
 
 set(GTEST_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/gtest")
 
-ExternalProject_Add(gtest
+# try to find git - if found, setup gtest
-	GIT_REPOSITORY https://chromium.googlesource.com/external/googletest
+find_package(Git)
-	TIMEOUT 10
+if(NOT GIT_FOUND)
-	PREFIX "${GTEST_PREFIX}"
+	set(AddGTest_FOUND false CACHE BOOL "Was gtest setup correctly?")
-	CMAKE_ARGS "${GTEST_CMAKE_ARGS}"
+else(NOT GIT_FOUND)
-	LOG_DOWNLOAD ON
+	set(AddGTest_FOUND true CACHE BOOL "Was gtest setup correctly?")
-	LOG_CONFIGURE ON
-	LOG_BUILD ON
-	# Disable install
-	INSTALL_COMMAND ""
-)
 	
-set(LIB_PREFIX "${CMAKE_STATIC_LIBRARY_PREFIX}")
+	ExternalProject_Add(gtest
-set(LIB_SUFFIX "${CMAKE_STATIC_LIBRARY_SUFFIX}")
+		GIT_REPOSITORY https://chromium.googlesource.com/external/googletest
-set(GTEST_LOCATION "${GTEST_PREFIX}/src/gtest-build")
+		TIMEOUT 10
-set(GTEST_DEBUG_LIBRARIES
+		PREFIX "${GTEST_PREFIX}"
-	"${GTEST_LOCATION}/${DEBUG_LIB_DIR}/${LIB_PREFIX}gtest${LIB_SUFFIX}"
+		CMAKE_ARGS "${GTEST_CMAKE_ARGS}"
-	"${CMAKE_THREAD_LIBS_INIT}")
+		LOG_DOWNLOAD ON
-SET(GTEST_RELEASE_LIBRARIES
+		LOG_CONFIGURE ON
-	"${GTEST_LOCATION}/${RELEASE_LIB_DIR}/${LIB_PREFIX}gtest${LIB_SUFFIX}"
+		LOG_BUILD ON
-	"${CMAKE_THREAD_LIBS_INIT}")
+		# Disable install
+		INSTALL_COMMAND ""
+	)
 
-if(MSVC_VERSION EQUAL 1700)
+	set(LIB_PREFIX "${CMAKE_STATIC_LIBRARY_PREFIX}")
-  add_definitions(-D_VARIADIC_MAX=10)
+	set(LIB_SUFFIX "${CMAKE_STATIC_LIBRARY_SUFFIX}")
-endif()
+	set(GTEST_LOCATION "${GTEST_PREFIX}/src/gtest-build")
+	set(GTEST_DEBUG_LIBRARIES
+		"${GTEST_LOCATION}/${DEBUG_LIB_DIR}/${LIB_PREFIX}gtest${LIB_SUFFIX}"
+		"${CMAKE_THREAD_LIBS_INIT}")
+	SET(GTEST_RELEASE_LIBRARIES
+		"${GTEST_LOCATION}/${RELEASE_LIB_DIR}/${LIB_PREFIX}gtest${LIB_SUFFIX}"
+		"${CMAKE_THREAD_LIBS_INIT}")
 
-ExternalProject_Get_Property(gtest source_dir)
+	if(MSVC_VERSION EQUAL 1700)
-include_directories(${source_dir}/include)
+	  add_definitions(-D_VARIADIC_MAX=10)
-include_directories(${source_dir}/gtest/include)
+	endif()
 
-ExternalProject_Get_Property(gtest binary_dir)
+	ExternalProject_Get_Property(gtest source_dir)
-link_directories(${binary_dir})
+	include_directories(${source_dir}/include)
+	include_directories(${source_dir}/gtest/include)
+
+	ExternalProject_Get_Property(gtest binary_dir)
+	link_directories(${binary_dir})
+endif(NOT GIT_FOUND)

code/3DSConverter.cpp

@@ -757,7 +757,7 @@ void Discreet3DSImporter::GenerateNodeGraph(aiScene* pcOut)
 			pcNode->mNumMeshes = 1;
 
 			// Build a name for the node
-			pcNode->mName.length = sprintf(pcNode->mName.data,"3DSMesh_%i",i);	
+			pcNode->mName.length = sprintf(pcNode->mName.data,"3DSMesh_%u",i);	
 		}
 
 		// Build dummy nodes for all cameras

code/3DSExporter.cpp

@@ -324,6 +324,7 @@ void Discreet3DSExporter::WriteMaterials()
 				break;
 
 			default:
+				shading_mode_out = Discreet3DS::Flat;
 				ai_assert(false);
 			};
 			writer.PutU2(static_cast<uint16_t>(shading_mode_out));

code/ASEParser.cpp

@@ -143,9 +143,9 @@ void Parser::LogWarning(const char* szWarn)
 
 	char szTemp[1024];
 #if _MSC_VER >= 1400
-	sprintf_s(szTemp,"Line %i: %s",iLineNumber,szWarn);
+	sprintf_s(szTemp,"Line %u: %s",iLineNumber,szWarn);
 #else
-	snprintf(szTemp,1024,"Line %i: %s",iLineNumber,szWarn);
+	snprintf(szTemp,1024,"Line %u: %s",iLineNumber,szWarn);
 #endif
 
 	// output the warning to the logger ...
@@ -159,9 +159,9 @@ void Parser::LogInfo(const char* szWarn)
 
 	char szTemp[1024];
 #if _MSC_VER >= 1400
-	sprintf_s(szTemp,"Line %i: %s",iLineNumber,szWarn);
+	sprintf_s(szTemp,"Line %u: %s",iLineNumber,szWarn);
 #else
-	snprintf(szTemp,1024,"Line %i: %s",iLineNumber,szWarn);
+	snprintf(szTemp,1024,"Line %u: %s",iLineNumber,szWarn);
 #endif
 
 	// output the information to the logger ...
@@ -175,9 +175,9 @@ AI_WONT_RETURN void Parser::LogError(const char* szWarn)
 
 	char szTemp[1024];
 #if _MSC_VER >= 1400
-	sprintf_s(szTemp,"Line %i: %s",iLineNumber,szWarn);
+	sprintf_s(szTemp,"Line %u: %s",iLineNumber,szWarn);
 #else
-	snprintf(szTemp,1024,"Line %i: %s",iLineNumber,szWarn);
+	snprintf(szTemp,1024,"Line %u: %s",iLineNumber,szWarn);
 #endif
 
 	// throw an exception

code/AssbinLoader.cpp

@@ -199,7 +199,8 @@ template <typename T> void ReadBounds( IOStream * stream, T* /*p*/, unsigned int
 
 void AssbinImporter::ReadBinaryNode( IOStream * stream, aiNode** node )
 {
-	ai_assert( Read<uint32_t>(stream) == ASSBIN_CHUNK_AINODE);
+	uint32_t chunkID = Read<uint32_t>(stream);
+	ai_assert(chunkID == ASSBIN_CHUNK_AINODE);
 	/*uint32_t size =*/ Read<uint32_t>(stream);
 
 	*node = new aiNode();
@@ -230,7 +231,8 @@ void AssbinImporter::ReadBinaryNode( IOStream * stream, aiNode** node )
 // -----------------------------------------------------------------------------------
 void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b )
 {
-	ai_assert( Read<uint32_t>(stream) == ASSBIN_CHUNK_AIBONE );
+	uint32_t chunkID = Read<uint32_t>(stream);
+	ai_assert(chunkID == ASSBIN_CHUNK_AIBONE);
 	/*uint32_t size =*/ Read<uint32_t>(stream);
 
 	b->mName = Read<aiString>(stream);
@@ -253,7 +255,8 @@ void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b )
 
 void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
 {
-	ai_assert( Read<uint32_t>(stream) == ASSBIN_CHUNK_AIMESH);
+	uint32_t chunkID = Read<uint32_t>(stream);
+	ai_assert(chunkID == ASSBIN_CHUNK_AIMESH);
 	/*uint32_t size =*/ Read<uint32_t>(stream);
 
 	mesh->mPrimitiveTypes = Read<unsigned int>(stream);
@@ -377,7 +380,8 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
 
 void AssbinImporter::ReadBinaryMaterialProperty(IOStream * stream, aiMaterialProperty* prop)
 {
-	ai_assert( Read<uint32_t>(stream) == ASSBIN_CHUNK_AIMATERIALPROPERTY);
+	uint32_t chunkID = Read<uint32_t>(stream);
+	ai_assert(chunkID == ASSBIN_CHUNK_AIMATERIALPROPERTY);
 	/*uint32_t size =*/ Read<uint32_t>(stream);
 
 	prop->mKey = Read<aiString>(stream);
@@ -393,7 +397,8 @@ void AssbinImporter::ReadBinaryMaterialProperty(IOStream * stream, aiMaterialPro
 // -----------------------------------------------------------------------------------
 void AssbinImporter::ReadBinaryMaterial(IOStream * stream, aiMaterial* mat)
 {
-	ai_assert( Read<uint32_t>(stream) == ASSBIN_CHUNK_AIMATERIAL);
+	uint32_t chunkID = Read<uint32_t>(stream);
+	ai_assert(chunkID == ASSBIN_CHUNK_AIMATERIAL);
 	/*uint32_t size =*/ Read<uint32_t>(stream);
 
 	mat->mNumAllocated = mat->mNumProperties = Read<unsigned int>(stream);
@@ -414,7 +419,8 @@ void AssbinImporter::ReadBinaryMaterial(IOStream * stream, aiMaterial* mat)
 // -----------------------------------------------------------------------------------
 void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd)
 {
-	ai_assert( Read<uint32_t>(stream) == ASSBIN_CHUNK_AINODEANIM);
+	uint32_t chunkID = Read<uint32_t>(stream);
+	ai_assert(chunkID == ASSBIN_CHUNK_AINODEANIM);
 	/*uint32_t size =*/ Read<uint32_t>(stream);
 
 	nd->mNodeName = Read<aiString>(stream);
@@ -462,7 +468,8 @@ void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd)
 // -----------------------------------------------------------------------------------
 void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim )
 {
-	ai_assert( Read<uint32_t>(stream) == ASSBIN_CHUNK_AIANIMATION);
+	uint32_t chunkID = Read<uint32_t>(stream);
+	ai_assert(chunkID == ASSBIN_CHUNK_AIANIMATION);
 	/*uint32_t size =*/ Read<uint32_t>(stream);
 
 	anim->mName = Read<aiString> (stream);
@@ -482,7 +489,8 @@ void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim )
 
 void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex)
 {
-	ai_assert( Read<uint32_t>(stream) == ASSBIN_CHUNK_AITEXTURE);
+	uint32_t chunkID = Read<uint32_t>(stream);
+	ai_assert(chunkID == ASSBIN_CHUNK_AITEXTURE);
 	/*uint32_t size =*/ Read<uint32_t>(stream);
 
 	tex->mWidth = Read<unsigned int>(stream);
@@ -505,7 +513,8 @@ void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex)
 // -----------------------------------------------------------------------------------
 void AssbinImporter::ReadBinaryLight( IOStream * stream, aiLight* l )
 {
-	ai_assert( Read<uint32_t>(stream) == ASSBIN_CHUNK_AILIGHT);
+	uint32_t chunkID = Read<uint32_t>(stream);
+	ai_assert(chunkID == ASSBIN_CHUNK_AILIGHT);
 	/*uint32_t size =*/ Read<uint32_t>(stream);
 
 	l->mName = Read<aiString>(stream);
@@ -531,7 +540,8 @@ void AssbinImporter::ReadBinaryLight( IOStream * stream, aiLight* l )
 // -----------------------------------------------------------------------------------
 void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam )
 {
-	ai_assert( Read<uint32_t>(stream) == ASSBIN_CHUNK_AICAMERA);
+	uint32_t chunkID = Read<uint32_t>(stream);
+	ai_assert(chunkID == ASSBIN_CHUNK_AICAMERA);
 	/*uint32_t size =*/ Read<uint32_t>(stream);
 
 	cam->mName = Read<aiString>(stream);
@@ -546,7 +556,8 @@ void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam )
 
 void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
 {
-	ai_assert( Read<uint32_t>(stream) == ASSBIN_CHUNK_AISCENE);
+	uint32_t chunkID = Read<uint32_t>(stream);
+	ai_assert(chunkID == ASSBIN_CHUNK_AISCENE);
 	/*uint32_t size =*/ Read<uint32_t>(stream);
 
 	scene->mFlags         = Read<unsigned int>(stream);

code/Assimp.cpp

@@ -423,6 +423,21 @@ const char* aiGetErrorString()
 	return gLastErrorString.c_str();
 }
 
+// -----------------------------------------------------------------------------------------------
+// Return the description of a importer given its index
+const aiImporterDesc* aiGetImportFormatDescription( size_t pIndex)
+{
+	return Importer().GetImporterInfo(pIndex);
+}
+
+// -----------------------------------------------------------------------------------------------
+// Return the number of importers
+size_t aiGetImportFormatCount(void)
+{
+	return Importer().GetImporterCount();
+}
+
+
 // ------------------------------------------------------------------------------------------------
 // Returns the error text of the last failed import process. 
 aiBool aiIsExtensionSupported(const char* szExtension)

code/BaseImporter.cpp

@@ -155,11 +155,11 @@ void BaseImporter::GetExtensionList(std::set<std::string>& extensions)
 		boost::scoped_array<char> _buffer (new char[searchBytes+1 /* for the '\0' */]);
 		char* buffer = _buffer.get();
 
-		const unsigned int read = pStream->Read(buffer,1,searchBytes);
+		const size_t read = pStream->Read(buffer,1,searchBytes);
 		if (!read)
 			return false;
 
-		for (unsigned int i = 0; i < read;++i)
+		for (size_t i = 0; i < read; ++i)
 			buffer[i] = ::tolower(buffer[i]);
 
 		// It is not a proper handling of unicode files here ...
@@ -392,11 +392,11 @@ void BaseImporter::ConvertToUTF8(std::vector<char>& data)
 // Convert to UTF8 data to ISO-8859-1
 void BaseImporter::ConvertUTF8toISO8859_1(std::string& data)
 {
-	unsigned int size = data.size();
+	size_t size = data.size();
-	unsigned int i = 0, j = 0;
+	size_t i = 0, j = 0;
 
 	while(i < size) {
-		if((unsigned char) data[i] < 0x80) {
+		if ((unsigned char) data[i] < (size_t) 0x80) {
 			data[j] = data[i];
 		} else if(i < size - 1) {
 			if((unsigned char) data[i] == 0xC2) {
@@ -480,7 +480,9 @@ namespace Assimp
 struct Assimp::BatchData
 {
 	BatchData()
-		:	next_id(0xffff)
+        : pIOSystem()
+        , pImporter()
+        , next_id(0xffff)
 	{}
 
 	// IO system to be used for all imports

code/CMakeLists.txt

@@ -157,7 +157,27 @@ IF ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER )
 	SOURCE_GROUP( C4D FILES ${C4D_SRCS})
 ENDIF ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER )
 
-SET( 3DS_SRCS
+# macro to add the CMake Option ADD_ASSIMP_IMPORTER_<name> which enables compile of loader
+# this way selective loaders can be compiled (reduces filesize + compile time)
+MACRO(ADD_ASSIMP_IMPORTER name)
+	OPTION(ASSIMP_BUILD_${name}_IMPORTER "build the ${name} importer" TRUE)
+	IF(ASSIMP_BUILD_${name}_IMPORTER)
+		LIST(APPEND ASSIMP_LOADER_SRCS ${ARGN})
+		SET(ASSIMP_IMPORTERS_ENABLED "${ASSIMP_IMPORTERS_ENABLED} ${name}")
+		SET(${name}_SRCS ${ARGN})
+		SOURCE_GROUP(${name} FILES ${ARGN})
+	ELSE()
+		SET(${name}_SRC "")
+		SET(ASSIMP_IMPORTERS_DISABLED "${ASSIMP_IMPORTERS_DISABLED} ${name}")
+		add_definitions(-DASSIMP_BUILD_NO_${name}_IMPORTER)
+	ENDIF()
+ENDMACRO()
+
+SET(ASSIMP_LOADER_SRCS "")
+SET(ASSIMP_IMPORTERS_ENABLED "") # list of enabled importers
+SET(ASSIMP_IMPORTERS_DISABLED "") # disabled list (used to print)
+
+ADD_ASSIMP_IMPORTER(3DS
 	3DSConverter.cpp
 	3DSHelper.h
 	3DSLoader.cpp
@@ -165,49 +185,42 @@ SET( 3DS_SRCS
 	3DSExporter.h
 	3DSExporter.cpp
 )
-SOURCE_GROUP(3DS FILES ${3DS_SRCS})
 
-SET( AC_SRCS
+ADD_ASSIMP_IMPORTER(AC
 	ACLoader.cpp
 	ACLoader.h
 )
-SOURCE_GROUP( AC FILES ${AC_SRCS})
 
-SET( ASE_SRCS
+ADD_ASSIMP_IMPORTER(ASE
 	ASELoader.cpp
 	ASELoader.h
 	ASEParser.cpp
 	ASEParser.h
 )
-SOURCE_GROUP( ASE FILES ${ASE_SRCS})
 
-SET( ASSBIN_SRCS
+ADD_ASSIMP_IMPORTER(ASSBIN
 	AssbinExporter.h
 	AssbinExporter.cpp
 	AssbinLoader.h
 	AssbinLoader.cpp
 )
-SOURCE_GROUP( Assbin FILES ${ASSBIN_SRCS})
 
-SET( ASSXML_SRCS
+ADD_ASSIMP_IMPORTER(ASSXML
 	AssxmlExporter.h
 	AssxmlExporter.cpp
 )
-SOURCE_GROUP( Assxml FILES ${ASSXML_SRCS})
 
-SET( B3D_SRCS
+ADD_ASSIMP_IMPORTER(B3D
 	B3DImporter.cpp
 	B3DImporter.h
 )
-SOURCE_GROUP( B3D FILES ${B3D_SRCS})
 
-SET( BVH_SRCS
+ADD_ASSIMP_IMPORTER(BVH
 	BVHLoader.cpp
 	BVHLoader.h
 )
-SOURCE_GROUP( BVH FILES ${BVH_SRCS})
 
-SET( Collada_SRCS
+ADD_ASSIMP_IMPORTER(COLLADA
 	ColladaHelper.h
 	ColladaLoader.cpp
 	ColladaLoader.h
@@ -216,30 +229,27 @@ SET( Collada_SRCS
 	ColladaExporter.h
 	ColladaExporter.cpp
 )
-SOURCE_GROUP( Collada FILES ${Collada_SRCS})
 
-SET( DXF_SRCS
+ADD_ASSIMP_IMPORTER(DXF
 	DXFLoader.cpp
 	DXFLoader.h
 	DXFHelper.h
 )
-SOURCE_GROUP( DXF FILES ${DXF_SRCS})
 
-SET( CSM_SRCS
+ADD_ASSIMP_IMPORTER(CSM
 	CSMLoader.cpp
 	CSMLoader.h
 )
-SOURCE_GROUP( CSM FILES ${CSM_SRCS})
 
-SET( HMP_SRCS
+ADD_ASSIMP_IMPORTER(HMP
 	HMPFileData.h
 	HMPLoader.cpp
 	HMPLoader.h
 	HalfLifeFileData.h
 )
-SOURCE_GROUP( HMP FILES ${HMP_SRCS})
 
-SET( Irr_SRCS
+#FIXME: allow to set IRRMESH by option
+ADD_ASSIMP_IMPORTER(IRR
 	IRRLoader.cpp
 	IRRLoader.h
 	IRRMeshLoader.cpp
@@ -247,9 +257,8 @@ SET( Irr_SRCS
 	IRRShared.cpp
 	IRRShared.h
 )
-SOURCE_GROUP( Irr FILES ${Irr_SRCS})
 
-SET( LWO_SRCS
+ADD_ASSIMP_IMPORTER(LWO
 	LWOAnimation.cpp
 	LWOAnimation.h
 	LWOBLoader.cpp
@@ -258,53 +267,46 @@ SET( LWO_SRCS
 	LWOLoader.h
 	LWOMaterial.cpp
 )
-SOURCE_GROUP( LWO FILES ${LWO_SRCS})
 
-SET( LWS_SRCS
+ADD_ASSIMP_IMPORTER(LWS
 	LWSLoader.cpp
 	LWSLoader.h
 )
-SOURCE_GROUP( LWS FILES ${LWS_SRCS})
 
-SET( MD2_SRCS
+ADD_ASSIMP_IMPORTER(MD2
 	MD2FileData.h
 	MD2Loader.cpp
 	MD2Loader.h
 	MD2NormalTable.h
 )
-SOURCE_GROUP( MD2 FILES ${MD2_SRCS})
 
-SET( MD3_SRCS
+ADD_ASSIMP_IMPORTER(MD3
 	MD3FileData.h
 	MD3Loader.cpp
 	MD3Loader.h
 )
-SOURCE_GROUP( MD3 FILES ${MD3_SRCS})
 
-SET( MD5_SRCS
+ADD_ASSIMP_IMPORTER(MD5
 	MD5Loader.cpp
 	MD5Loader.h
 	MD5Parser.cpp
 	MD5Parser.h
 )
-SOURCE_GROUP( MD5 FILES ${MD5_SRCS})
 
-SET( MDC_SRCS
+ADD_ASSIMP_IMPORTER(MDC
 	MDCFileData.h
 	MDCLoader.cpp
 	MDCLoader.h
 	MDCNormalTable.h
 )
-SOURCE_GROUP( MDC FILES ${MDC_SRCS})
 
-SET( MDL_SRCS
+ADD_ASSIMP_IMPORTER(MDL
 	MDLDefaultColorMap.h
 	MDLFileData.h
 	MDLLoader.cpp
 	MDLLoader.h
 	MDLMaterialLoader.cpp
 )
-SOURCE_GROUP( MDL FILES ${MDL_SRCS})
 
 SET( MaterialSystem_SRCS
 	MaterialSystem.cpp
@@ -312,25 +314,22 @@ SET( MaterialSystem_SRCS
 )
 SOURCE_GROUP( MaterialSystem FILES ${MaterialSystem_SRCS})
 
-SET( NFF_SRCS
+ADD_ASSIMP_IMPORTER(NFF
 	NFFLoader.cpp
 	NFFLoader.h
 )
-SOURCE_GROUP( NFF FILES ${NFF_SRCS})
 
-SET( NDO_SRCS
+ADD_ASSIMP_IMPORTER(NDO
 	NDOLoader.cpp
 	NDOLoader.h
 )
-SOURCE_GROUP( NDO FILES ${NDO_SRCS})
 
-SET( OFFFormat_SRCS
+ADD_ASSIMP_IMPORTER(OFF
 	OFFLoader.cpp
 	OFFLoader.h
 )
-SOURCE_GROUP( OFFFormat FILES ${OFFFormat_SRCS})
 
-SET( Obj_SRCS
+ADD_ASSIMP_IMPORTER(OBJ
 	ObjFileData.h
 	ObjFileImporter.cpp
 	ObjFileImporter.h
@@ -343,9 +342,8 @@ SET( Obj_SRCS
 	ObjExporter.h
 	ObjExporter.cpp
 )
-SOURCE_GROUP( Obj FILES ${Obj_SRCS})
 
-SET( Ogre_SRCS
+ADD_ASSIMP_IMPORTER(OGRE
 	OgreImporter.h
 	OgreStructs.h
 	OgreParsingUtils.h
@@ -357,16 +355,14 @@ SET( Ogre_SRCS
 	OgreXmlSerializer.cpp
 	OgreMaterial.cpp
 )
-SOURCE_GROUP( Ogre FILES ${Ogre_SRCS})
 
-SET( OpenGEX_SRCS
+ADD_ASSIMP_IMPORTER(OPENGEX
     OpenGEXImporter.cpp
     OpenGEXImporter.h
     OpenGEXStructs.h
 )
-SOURCE_GROUP( OpenGEX FILES ${OpenGEX_SRCS})
 
-SET( Ply_SRCS
+ADD_ASSIMP_IMPORTER(PLY
 	PlyLoader.cpp
 	PlyLoader.h
 	PlyParser.cpp
@@ -374,22 +370,19 @@ SET( Ply_SRCS
 	PlyExporter.cpp
 	PlyExporter.h
 )
-SOURCE_GROUP( Ply FILES ${Ply_SRCS})
 
-SET(MS3D_SRCS
+ADD_ASSIMP_IMPORTER(MS3D
 	MS3DLoader.cpp
 	MS3DLoader.h
 )
-SOURCE_GROUP( MS3D FILES ${MS3D_SRCS})
 
-SET(COB_SRCS
+ADD_ASSIMP_IMPORTER(COB
 	COBLoader.cpp
 	COBLoader.h
 	COBScene.h
 )
-SOURCE_GROUP( COB FILES ${COB_SRCS})
 
-SET(BLENDER_SRCS
+ADD_ASSIMP_IMPORTER(BLEND
 	BlenderLoader.cpp
 	BlenderLoader.h
 	BlenderDNA.cpp
@@ -406,9 +399,8 @@ SET(BLENDER_SRCS
 	BlenderTessellator.h
 	BlenderTessellator.cpp
 )
-SOURCE_GROUP( BLENDER FILES ${BLENDER_SRCS})
 
-SET(IFC_SRCS
+ADD_ASSIMP_IMPORTER(IFC
 	IFCLoader.cpp
 	IFCLoader.h
 	IFCReaderGen.cpp
@@ -427,16 +419,14 @@ SET(IFC_SRCS
 	STEPFileEncoding.cpp
 	STEPFileEncoding.h
 )
-SOURCE_GROUP( IFC FILES ${IFC_SRCS})
 
-SET( XGL_SRCS
+ADD_ASSIMP_IMPORTER(XGL
 	XGLLoader.cpp
 	XGLLoader.h
 )
-SOURCE_GROUP( XGL FILES ${XGL_SRCS})
 
 
-SET(FBX_SRCS
+ADD_ASSIMP_IMPORTER(FBX
 	FBXImporter.cpp
 	FBXCompileConfig.h
 	FBXImporter.h
@@ -462,8 +452,6 @@ SET(FBX_SRCS
 	FBXBinaryTokenizer.cpp
 	FBXDocumentUtil.cpp
 )
-SOURCE_GROUP( FBX FILES ${FBX_SRCS})
-
 
 SET( PostProcessing_SRCS
 	CalcTangentsProcess.cpp
@@ -520,13 +508,12 @@ SET( PostProcessing_SRCS
 )
 SOURCE_GROUP( PostProcessing FILES ${PostProcessing_SRCS})
 
-SET( Q3D_SRCS
+ADD_ASSIMP_IMPORTER(Q3D
 	Q3DLoader.cpp
 	Q3DLoader.h
 )
-SOURCE_GROUP( Q3D FILES ${Q3D_SRCS})
 
-SET( Q3BSP_SRCS
+ADD_ASSIMP_IMPORTER(Q3BSP
 	Q3BSPFileData.h
 	Q3BSPFileParser.h
 	Q3BSPFileParser.cpp
@@ -535,41 +522,35 @@ SET( Q3BSP_SRCS
 	Q3BSPZipArchive.h
 	Q3BSPZipArchive.cpp
 )
-SOURCE_GROUP( Q3BSP FILES ${Q3BSP_SRCS})
 
-SET( Raw_SRCS
+ADD_ASSIMP_IMPORTER(RAW
 	RawLoader.cpp
 	RawLoader.h
 )
-SOURCE_GROUP( Raw FILES ${Raw_SRCS})
 
-SET( SMD_SRCS
+ADD_ASSIMP_IMPORTER(SMD
 	SMDLoader.cpp
 	SMDLoader.h
 )
-SOURCE_GROUP( SMD FILES ${SMD_SRCS})
 
-SET( STL_SRCS
+ADD_ASSIMP_IMPORTER(STL
 	STLLoader.cpp
 	STLLoader.h
 	STLExporter.h
 	STLExporter.cpp
 )
-SOURCE_GROUP( STL FILES ${STL_SRCS})
 
-SET( Terragen_SRCS
+ADD_ASSIMP_IMPORTER(TERRAGEN
 	TerragenLoader.cpp
 	TerragenLoader.h
 )
-SOURCE_GROUP( Terragen FILES ${Terragen_SRCS})
 
-SET( Unreal_SRCS
+ADD_ASSIMP_IMPORTER(3D
 	UnrealLoader.cpp
 	UnrealLoader.h
 )
-SOURCE_GROUP( Unreal FILES ${Unreal_SRCS})
 
-SET( XFile_SRCS
+ADD_ASSIMP_IMPORTER(X
 	XFileHelper.h
 	XFileImporter.cpp
 	XFileImporter.h
@@ -578,7 +559,6 @@ SET( XFile_SRCS
 	XFileExporter.h
 	XFileExporter.cpp
 )
-SOURCE_GROUP( XFile FILES ${XFile_SRCS})
 
 SET( Step_SRCS
 	StepExporter.h
@@ -680,6 +660,9 @@ else (UNZIP_FOUND)
 	SET (unzip_compile_SRCS ${unzip_SRCS})
 endif (UNZIP_FOUND)
 
+MESSAGE(STATUS "Enabled formats:${ASSIMP_IMPORTERS_ENABLED}")
+MESSAGE(STATUS "Disabled formats:${ASSIMP_IMPORTERS_DISABLED}")
+
 SET( assimp_src
 	# Assimp Files
 	${Core_SRCS}
@@ -687,51 +670,11 @@ SET( assimp_src
 	${Logging_SRCS}
 	${Exporter_SRCS}
 	${PostProcessing_SRCS}
+	${MaterialSystem_SRCS}
+	${Step_SRCS}
 
 	# Model Support
-	${3DS_SRCS}
+	${ASSIMP_LOADER_SRCS}
-	${AC_SRCS}
-	${ASE_SRCS}
-	${ASSBIN_SRCS}
-	${ASSXML_SRCS}
-	${B3D_SRCS}
-	${BVH_SRCS}
-	${Collada_SRCS}
-	${DXF_SRCS}
-	${CSM_SRCS}
-	${HMP_SRCS}
-	${Irr_SRCS}
-	${LWO_SRCS}
-	${LWS_SRCS}
-	${MD2_SRCS}
-	${MD3_SRCS}
-	${MD5_SRCS}
-	${MDC_SRCS}
-	${MDL_SRCS}
-	${MaterialSystem_SRCS}
-	${NFF_SRCS}
-	${OFFFormat_SRCS}
-	${Obj_SRCS}
-	${Ogre_SRCS}
-    ${OpenGEX_SRCS}
-	${Ply_SRCS}
-	${Q3D_SRCS}
-	${Q3BSP_SRCS}
-	${Raw_SRCS}
-	${SMD_SRCS}
-	${STL_SRCS}
-	${Terragen_SRCS}
-	${Unreal_SRCS}
-	${XFile_SRCS}
-	${Step_SRCS}
-	${Extra_SRCS}
-	${MS3D_SRCS}
-	${COB_SRCS}
-	${BLENDER_SRCS}
-	${NDO_SRCS}
-	${IFC_SRCS}
-	${XGL_SRCS}
-	${FBX_SRCS}
 
 	# Third-party libraries
 	${IrrXML_SRCS}
@@ -739,7 +682,7 @@ SET( assimp_src
 	${unzip_compile_SRCS}
 	${Poly2Tri_SRCS}
 	${Clipper_SRCS}
-    ${openddl_parser_SRCS}
+	${openddl_parser_SRCS}
 	# Necessary to show the headers in the project when using the VC++ generator:
 	${Boost_SRCS}
 

code/ColladaExporter.cpp

@@ -127,6 +127,8 @@ void ColladaExporter::WriteFile()
 	WriteTextures();
 	WriteHeader();
 
+	WriteCamerasLibrary();
+	WriteLightsLibrary();
 	WriteMaterials();
 	WriteGeometryLibrary();
 
@@ -165,8 +167,6 @@ void ColladaExporter::WriteHeader()
 	std::time_t date = std::time(NULL);
 	std::strftime(date_str, date_nb_chars, "%Y-%m-%dT%H:%M:%S", std::localtime(&date));
 
-	std::string scene_name = mScene->mRootNode->mName.C_Str();
-
 	aiVector3D scaling;
 	aiQuaternion rotation;
 	aiVector3D position;
@@ -286,6 +286,201 @@ void ColladaExporter::WriteTextures() {
 	}
 }
 
+// ------------------------------------------------------------------------------------------------
+// Write the embedded textures
+void ColladaExporter::WriteCamerasLibrary() {
+	if(mScene->HasCameras()) {
+
+		mOutput << startstr << "<library_cameras>" << endstr;
+		PushTag();
+
+		for( size_t a = 0; a < mScene->mNumCameras; ++a)
+			WriteCamera( a);
+
+		PopTag();
+		mOutput << startstr << "</library_cameras>" << endstr;
+
+	}
+}
+
+void ColladaExporter::WriteCamera(size_t pIndex){
+
+	const aiCamera *cam = mScene->mCameras[pIndex];
+	const std::string idstrEscaped = XMLEscape(cam->mName.C_Str());
+
+	mOutput << startstr << "<camera id=\"" << idstrEscaped << "-camera\" name=\"" << idstrEscaped << "_name\" >" << endstr;
+	PushTag();
+	mOutput << startstr << "<optics>" << endstr;
+	PushTag();
+	mOutput << startstr << "<technique_common>" << endstr;
+	PushTag();
+	//assimp doesn't support the import of orthographic cameras! se we write
+	//always perspective
+	mOutput << startstr << "<perspective>" << endstr;
+	PushTag();
+	mOutput << startstr << "<xfov sid=\"xfov\">"<<
+								AI_RAD_TO_DEG(cam->mHorizontalFOV)
+						<<"</xfov>" << endstr;
+	mOutput << startstr << "<aspect_ratio>"
+						<<		cam->mAspect
+						<< "</aspect_ratio>" << endstr;
+	mOutput << startstr << "<znear sid=\"znear\">"
+						<<		cam->mClipPlaneNear
+						<<	"</znear>" << endstr;
+	mOutput << startstr << "<zfar sid=\"zfar\">"
+						<<		cam->mClipPlaneFar
+						<< "</zfar>" << endstr;
+	PopTag();
+	mOutput << startstr << "</perspective>" << endstr;
+	PopTag();
+	mOutput << startstr << "</technique_common>" << endstr;
+	PopTag();
+	mOutput << startstr << "</optics>" << endstr;
+	PopTag();
+	mOutput << startstr << "</camera>" << endstr;
+
+}
+
+
+// ------------------------------------------------------------------------------------------------
+// Write the embedded textures
+void ColladaExporter::WriteLightsLibrary() {
+	if(mScene->HasLights()) {
+
+		mOutput << startstr << "<library_lights>" << endstr;
+		PushTag();
+
+		for( size_t a = 0; a < mScene->mNumLights; ++a)
+			WriteLight( a);
+
+		PopTag();
+		mOutput << startstr << "</library_lights>" << endstr;
+
+	}
+}
+
+void ColladaExporter::WriteLight(size_t pIndex){
+
+	const aiLight *light = mScene->mLights[pIndex];
+	const std::string idstrEscaped = XMLEscape(light->mName.C_Str());
+
+	mOutput << startstr << "<light id=\"" << idstrEscaped << "-light\" name=\""
+			<< idstrEscaped << "_name\" >" << endstr;
+	PushTag();
+	mOutput << startstr << "<technique_common>" << endstr;
+	PushTag();
+	switch(light->mType){
+		case aiLightSource_AMBIENT:
+			WriteAmbienttLight(light);
+			break;
+		case aiLightSource_DIRECTIONAL:
+			WriteDirectionalLight(light);
+			break;
+		case aiLightSource_POINT:
+			WritePointLight(light);
+			break;
+		case aiLightSource_SPOT:
+			WriteSpotLight(light);
+			break;
+		case aiLightSource_UNDEFINED:
+		case _aiLightSource_Force32Bit:
+			break;
+	}
+	PopTag();
+	mOutput << startstr << "</technique_common>" << endstr;
+
+	PopTag();
+	mOutput << startstr << "</light>" << endstr;
+
+}
+
+void ColladaExporter::WritePointLight(const aiLight *const light){
+	const aiColor3D &color=  light->mColorDiffuse;
+	mOutput << startstr << "<point>" << endstr;
+	PushTag();
+	mOutput << startstr << "<color sid=\"color\">"
+							<< color.r<<" "<<color.g<<" "<<color.b
+						<<"</color>" << endstr;
+	mOutput << startstr << "<constant_attenuation>"
+							<< light->mAttenuationConstant
+						<<"</constant_attenuation>" << endstr;
+	mOutput << startstr << "<linear_attenuation>"
+							<< light->mAttenuationLinear
+						<<"</linear_attenuation>" << endstr;
+	mOutput << startstr << "<quadratic_attenuation>"
+							<< light->mAttenuationQuadratic
+						<<"</quadratic_attenuation>" << endstr;
+
+	PopTag();
+	mOutput << startstr << "</point>" << endstr;
+
+}
+void ColladaExporter::WriteDirectionalLight(const aiLight *const light){
+	const aiColor3D &color=  light->mColorDiffuse;
+	mOutput << startstr << "<directional>" << endstr;
+	PushTag();
+	mOutput << startstr << "<color sid=\"color\">"
+							<< color.r<<" "<<color.g<<" "<<color.b
+						<<"</color>" << endstr;
+
+	PopTag();
+	mOutput << startstr << "</directional>" << endstr;
+
+}
+void ColladaExporter::WriteSpotLight(const aiLight *const light){
+
+	const aiColor3D &color=  light->mColorDiffuse;
+	mOutput << startstr << "<spot>" << endstr;
+	PushTag();
+	mOutput << startstr << "<color sid=\"color\">"
+							<< color.r<<" "<<color.g<<" "<<color.b
+						<<"</color>" << endstr;
+	mOutput << startstr << "<constant_attenuation>"
+								<< light->mAttenuationConstant
+							<<"</constant_attenuation>" << endstr;
+	mOutput << startstr << "<linear_attenuation>"
+							<< light->mAttenuationLinear
+						<<"</linear_attenuation>" << endstr;
+	mOutput << startstr << "<quadratic_attenuation>"
+							<< light->mAttenuationQuadratic
+						<<"</quadratic_attenuation>" << endstr;
+	/*
+	out->mAngleOuterCone = AI_DEG_TO_RAD (std::acos(std::pow(0.1f,1.f/srcLight->mFalloffExponent))+
+							srcLight->mFalloffAngle);
+	*/
+
+	const float fallOffAngle = AI_RAD_TO_DEG(light->mAngleInnerCone);
+	mOutput << startstr <<"<falloff_angle sid=\"fall_off_angle\">"
+								<< fallOffAngle
+						<<"</falloff_angle>" << endstr;
+	double temp = light->mAngleOuterCone-light->mAngleInnerCone;
+
+	temp = std::cos(temp);
+	temp = std::log(temp)/std::log(0.1);
+	temp = 1/temp;
+	mOutput << startstr << "<falloff_exponent sid=\"fall_off_exponent\">"
+							<< temp
+						<<"</falloff_exponent>" << endstr;
+
+
+	PopTag();
+	mOutput << startstr << "</spot>" << endstr;
+
+}
+
+void ColladaExporter::WriteAmbienttLight(const aiLight *const light){
+
+	const aiColor3D &color=  light->mColorAmbient;
+	mOutput << startstr << "<ambient>" << endstr;
+	PushTag();
+	mOutput << startstr << "<color sid=\"color\">"
+							<< color.r<<" "<<color.g<<" "<<color.b
+						<<"</color>" << endstr;
+
+	PopTag();
+	mOutput << startstr << "</ambient>" << endstr;
+}
+
 // ------------------------------------------------------------------------------------------------
 // Reads a single surface entry from the given material keys
 void ColladaExporter::ReadMaterialSurface( Surface& poSurface, const aiMaterial* pSrcMat, aiTextureType pTexture, const char* pKey, size_t pType, size_t pIndex)
@@ -425,8 +620,6 @@ void ColladaExporter::WriteMaterials()
 {
   materials.resize( mScene->mNumMaterials);
 
-  std::set<std::string> material_names;
-
   /// collect all materials from the scene
   size_t numTextures = 0;
   for( size_t a = 0; a < mScene->mNumMaterials; ++a )
@@ -847,6 +1040,23 @@ void ColladaExporter::WriteNode(aiNode* pNode)
 	mOutput << mat.d1 << " " << mat.d2 << " " << mat.d3 << " " << mat.d4;
 	mOutput << "</matrix>" << endstr;
 
+	if(pNode->mNumMeshes==0){
+		//check if it is a camera node
+		for(size_t i=0; i<mScene->mNumCameras; i++){
+			if(mScene->mCameras[i]->mName == pNode->mName){
+				mOutput << startstr <<"<instance_camera url=\"#" << node_name_escaped << "-camera\"/>" << endstr;
+				break;
+			}
+		}
+		//check if it is a light node
+		for(size_t i=0; i<mScene->mNumLights; i++){
+			if(mScene->mLights[i]->mName == pNode->mName){
+				mOutput << startstr <<"<instance_light url=\"#" << node_name_escaped << "-light\"/>" << endstr;
+				break;
+			}
+		}
+
+	}else
 	// instance every geometry
 	for( size_t a = 0; a < pNode->mNumMeshes; ++a )
 	{
@@ -854,9 +1064,8 @@ void ColladaExporter::WriteNode(aiNode* pNode)
 	// do not instanciate mesh if empty. I wonder how this could happen
 	if( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
 		continue;
-
+	mOutput << startstr << "<instance_geometry url=\"#" << XMLEscape(GetMeshId( pNode->mMeshes[a])) << "\">" << endstr;
-		mOutput << startstr << "<instance_geometry url=\"#" << XMLEscape(GetMeshId( pNode->mMeshes[a])) << "\">" << endstr;
+	PushTag();
-		PushTag();
 	mOutput << startstr << "<bind_material>" << endstr;
 	PushTag();
 	mOutput << startstr << "<technique_common>" << endstr;

code/ColladaExporter.h

@@ -47,6 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../include/assimp/ai_assert.h"
 #include "../include/assimp/material.h"
 #include "../include/assimp/mesh.h"
+#include "../include/assimp/light.h"
 #include "../include/assimp/Exporter.hpp"
 #include <sstream>
 #include <vector>
@@ -83,6 +84,22 @@ protected:
 	/// Writes the material setup
 	void WriteMaterials();
 
+	/// Writes the cameras library
+	void WriteCamerasLibrary();
+
+	// Write a camera entry
+	void WriteCamera(size_t pIndex);
+
+	/// Writes the cameras library
+	void WriteLightsLibrary();
+
+	// Write a camera entry
+	void WriteLight(size_t pIndex);
+	void WritePointLight(const aiLight *const light);
+	void WriteDirectionalLight(const aiLight *const light);
+	void WriteSpotLight(const aiLight *const light);
+	void WriteAmbienttLight(const aiLight *const light);
+
 	/// Writes the geometry library
 	void WriteGeometryLibrary();
 
@@ -144,8 +161,11 @@ protected:
   struct Property
   {
     bool exist;
-	float value;
+	 float value;
-	Property() { exist = false; }
+	 Property()
+         : exist(false)
+         , value(0.0f)
+     {}
   };
 
   // summarize a material in an convinient way. 

code/ColladaHelper.h

@@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <map>
 #include <vector>
 #include <stdint.h>
-#include "../include/assimp/types.h"
+#include "../include/assimp/light.h"
 #include "../include/assimp/mesh.h"
 #include "../include/assimp/material.h"
 
@@ -134,7 +134,8 @@ struct Camera
 struct Light
 {	
 	Light()
-		:	mAttConstant     (1.f)
+		:	mType            (aiLightSource_UNDEFINED)
+		,	mAttConstant     (1.f)
 		,	mAttLinear       (0.f)
 		,	mAttQuadratic    (0.f)
 		,	mFalloffAngle    (180.f)
@@ -172,13 +173,14 @@ struct Light
 struct InputSemanticMapEntry
 {
 	InputSemanticMapEntry()
-		:	mSet	(0)
+		:	mSet(0)
+		,	mType(IT_Invalid)
 	{}
 
 	//! Index of set, optional
 	unsigned int mSet;
 
-	//! Name of referenced vertex input
+	//! Type of referenced vertex input
 	InputType mType;
 };
 
@@ -235,7 +237,7 @@ struct Node
 {
 	std::string mName;
 	std::string mID;
-  std::string mSID;
+    std::string mSID;
 	Node* mParent;
 	std::vector<Node*> mChildren;
 
@@ -384,8 +386,8 @@ struct Controller
 	// accessor URL of the joint names
 	std::string mJointNameSource;
 
-  ///< The bind shape matrix, as array of floats. I'm not sure what this matrix actually describes, but it can't be ignored in all cases
+    ///< The bind shape matrix, as array of floats. I'm not sure what this matrix actually describes, but it can't be ignored in all cases
-  float mBindShapeMatrix[16];
+    float mBindShapeMatrix[16];
 
 	// accessor URL of the joint inverse bind matrices
 	std::string mJointOffsetMatrixSource;
@@ -609,7 +611,15 @@ struct ChannelEntry
 	const Collada::Accessor* mValueAccessor; ///> Collada accessor to the key value values
 	const Collada::Data* mValueData; ///> Source datat array for the key value values
 
-	ChannelEntry() { mChannel = NULL; mSubElement = 0; }
+	ChannelEntry()
+      : mChannel()
+      , mTransformIndex()
+      , mSubElement()
+      , mTimeAccessor()
+      , mTimeData()
+      , mValueAccessor()
+      , mValueData()
+   {}
 };
 
 } // end of namespace Collada

code/ColladaLoader.cpp

@@ -81,7 +81,10 @@ static const aiImporterDesc desc = {
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 ColladaLoader::ColladaLoader()
-: noSkeletonMesh(), ignoreUpDirection(false), mNodeNameCounter()
+    : noSkeletonMesh()
+    , ignoreUpDirection(false)
+    , invertTransparency(false)
+    , mNodeNameCounter()
 {}
 
 // ------------------------------------------------------------------------------------------------
@@ -346,8 +349,8 @@ void ColladaLoader::BuildLightsForNode( const ColladaParser& pParser, const Coll
 				{
 					// Need to rely on falloff_exponent. I don't know how to interpret it, so I need to guess ....
 					// epsilon chosen to be 0.1
-					out->mAngleOuterCone = AI_DEG_TO_RAD (std::acos(std::pow(0.1f,1.f/srcLight->mFalloffExponent))+
+					out->mAngleOuterCone = std::acos(std::pow(0.1f,1.f/srcLight->mFalloffExponent))+
-						srcLight->mFalloffAngle);
+							out->mAngleInnerCone;
 				}
 				else {
 					out->mAngleOuterCone = out->mAngleInnerCone + AI_DEG_TO_RAD(  srcLight->mPenumbraAngle );
@@ -916,7 +919,7 @@ void ColladaLoader::StoreAnimations( aiScene* pScene, const ColladaParser& pPars
 
 // ------------------------------------------------------------------------------------------------
 // Constructs the animations for the given source anim 
-void ColladaLoader::StoreAnimations( aiScene* pScene, const ColladaParser& pParser, const Collada::Animation* pSrcAnim, const std::string pPrefix)
+void ColladaLoader::StoreAnimations( aiScene* pScene, const ColladaParser& pParser, const Collada::Animation* pSrcAnim, const std::string &pPrefix)
 {
 	std::string animName = pPrefix.empty() ? pSrcAnim->mName : pPrefix + "_" + pSrcAnim->mName;
 

code/ColladaLoader.h

@@ -155,7 +155,7 @@ protected:
 	 * @param pSrcAnim the source animation to process
 	 * @param pPrefix Prefix to the name in case of nested animations
 	 */
-	void StoreAnimations( aiScene* pScene, const ColladaParser& pParser, const Collada::Animation* pSrcAnim, const std::string pPrefix);
+	void StoreAnimations( aiScene* pScene, const ColladaParser& pParser, const Collada::Animation* pSrcAnim, const std::string& pPrefix);
 
 	/** Constructs the animation for the given source anim */
 	void CreateAnimation( aiScene* pScene, const ColladaParser& pParser, const Collada::Animation* pSrcAnim, const std::string& pName);

code/ComputeUVMappingProcess.cpp

@@ -412,7 +412,7 @@ void ComputeUVMappingProcess::Execute( aiScene* pScene)
 				{
 					if (!DefaultLogger::isNullLogger())
 					{
-						sprintf(buffer, "Found non-UV mapped texture (%s,%i). Mapping type: %s",
+						sprintf(buffer, "Found non-UV mapped texture (%s,%u). Mapping type: %s",
 							TextureTypeToString((aiTextureType)prop->mSemantic),prop->mIndex,
 							MappingTypeToString(mapping));
 

code/DeboneProcess.cpp

@@ -147,7 +147,7 @@ void DeboneProcess::Execute( aiScene* pScene)
 						   
 				if(!DefaultLogger::isNullLogger()) {
 					char buffer[1024];
-					::sprintf(buffer,"Removed %i bones. Input bones: %i. Output bones: %i",in-out,in,out);
+					::sprintf(buffer,"Removed %u bones. Input bones: %u. Output bones: %u",in-out,in,out);
 					DefaultLogger::get()->info(buffer);
 				}
 

code/DefaultLogger.cpp

@@ -258,7 +258,7 @@ void DefaultLogger::OnDebug( const char* message )
 		return;
 
 	char msg[MAX_LOG_MESSAGE_LENGTH + 16];
-	::sprintf(msg,"Debug, T%i: %s", GetThreadID(), message );
+	::sprintf(msg,"Debug, T%u: %s", GetThreadID(), message );
 
 	WriteToStreams( msg, Logger::Debugging );
 }
@@ -268,7 +268,7 @@ void DefaultLogger::OnDebug( const char* message )
 void DefaultLogger::OnInfo( const char* message )
 {
 	char msg[MAX_LOG_MESSAGE_LENGTH + 16];
-	::sprintf(msg,"Info,  T%i: %s", GetThreadID(), message );
+	::sprintf(msg,"Info,  T%u: %s", GetThreadID(), message );
 
 	WriteToStreams( msg , Logger::Info );
 }
@@ -278,7 +278,7 @@ void DefaultLogger::OnInfo( const char* message )
 void DefaultLogger::OnWarn( const char* message )
 {
 	char msg[MAX_LOG_MESSAGE_LENGTH + 16];
-	::sprintf(msg,"Warn,  T%i: %s", GetThreadID(), message );
+	::sprintf(msg,"Warn,  T%u: %s", GetThreadID(), message );
 
 	WriteToStreams( msg, Logger::Warn );
 }
@@ -288,7 +288,7 @@ void DefaultLogger::OnWarn( const char* message )
 void DefaultLogger::OnError( const char* message )
 {
 	char msg[MAX_LOG_MESSAGE_LENGTH + 16];
-	::sprintf(msg,"Error, T%i: %s", GetThreadID(), message );
+	::sprintf(msg,"Error, T%u: %s", GetThreadID(), message );
 
 	WriteToStreams( msg, Logger::Err );
 }

code/FBXParser.cpp

@@ -86,27 +86,6 @@ namespace {
 	}
 
 
-	// ------------------------------------------------------------------------------------------------
-	// print warning, do return
-	void ParseWarning(const std::string& message, const Token& token)
-	{
-		if(DefaultLogger::get()) {
-			DefaultLogger::get()->warn(Util::AddTokenText("FBX-Parser",message,&token));
-		}
-	}
-
-	// ------------------------------------------------------------------------------------------------
-/*	void ParseWarning(const std::string& message, const Element* element = NULL)
-	{
-		if(element) {
-			ParseWarning(message,element->KeyToken());
-			return;
-		}
-		if(DefaultLogger::get()) {
-			DefaultLogger::get()->warn("FBX-Parser: " + message);
-		}
-	}
-*/
 	// ------------------------------------------------------------------------------------------------
 	void ParseError(const std::string& message, TokenPtr token)
 	{

code/FindInvalidDataProcess.cpp

@@ -58,6 +58,7 @@ using namespace Assimp;
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 FindInvalidDataProcess::FindInvalidDataProcess()
+    : configEpsilon(0.0f)
 {
 	// nothing to do here
 }

code/FixNormalsStep.cpp

@@ -158,7 +158,7 @@ bool FixInfacingNormalsProcess::ProcessMesh( aiMesh* pcMesh, unsigned int index)
 		if (!DefaultLogger::isNullLogger())
 		{
 			char buffer[128]; // should be sufficiently large
-			::sprintf(buffer,"Mesh %i: Normals are facing inwards (or the mesh is planar)",index);
+			::sprintf(buffer,"Mesh %u: Normals are facing inwards (or the mesh is planar)",index);
 			DefaultLogger::get()->info(buffer);
 		}
 

code/IFCCurve.cpp

@@ -173,7 +173,6 @@ public:
 	// --------------------------------------------------
 	Line(const IfcLine& entity, ConversionData& conv) 
 		: Curve(entity,conv)
-		, entity(entity)
 	{
 		ConvertCartesianPoint(p,entity.Pnt);
 		ConvertVector(v,entity.Dir);
@@ -221,7 +220,6 @@ public:
 	}
 
 private:
-	const IfcLine& entity;
 	IfcVector3 p,v;
 };
 
@@ -238,7 +236,6 @@ public:
 	// --------------------------------------------------
 	CompositeCurve(const IfcCompositeCurve& entity, ConversionData& conv) 
 		: BoundedCurve(entity,conv)
-		, entity(entity)
 		, total()
 	{
 		curves.reserve(entity.Segments.size());
@@ -331,7 +328,6 @@ public:
 	}
 
 private:
-	const IfcCompositeCurve& entity;
 	std::vector< CurveEntry > curves;
 
 	IfcFloat total;
@@ -349,8 +345,6 @@ public:
 	// --------------------------------------------------
 	TrimmedCurve(const IfcTrimmedCurve& entity, ConversionData& conv) 
 		: BoundedCurve(entity,conv)
-		, entity(entity)
-		, ok()
 	{
 		base = boost::shared_ptr<const Curve>(Curve::Convert(entity.BasisCurve,conv));
 
@@ -448,11 +442,9 @@ private:
 
 
 private:
-	const IfcTrimmedCurve& entity;
 	ParamRange range;
 	IfcFloat maxval;
 	bool agree_sense;
-	bool ok;
 
 	boost::shared_ptr<const Curve> base;
 };
@@ -469,7 +461,6 @@ public:
 	// --------------------------------------------------
 	PolyLine(const IfcPolyline& entity, ConversionData& conv) 
 		: BoundedCurve(entity,conv)
-		, entity(entity)
 	{
 		points.reserve(entity.Points.size());
 
@@ -507,7 +498,6 @@ public:
 	}
 
 private:
-	const IfcPolyline& entity;
 	std::vector<IfcVector3> points;
 };
 

code/IFCLoader.cpp

@@ -93,8 +93,6 @@ namespace {
 void SetUnits(ConversionData& conv);
 void SetCoordinateSpace(ConversionData& conv);
 void ProcessSpatialStructures(ConversionData& conv);
-aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el ,ConversionData& conv);
-void ProcessProductRepresentation(const IfcProduct& el, aiNode* nd, ConversionData& conv);
 void MakeTreeRelative(ConversionData& conv);
 void ConvertUnit(const EXPRESS::DataType& dt,ConversionData& conv);
 
@@ -421,16 +419,6 @@ void ResolveObjectPlacement(aiMatrix4x4& m, const IfcObjectPlacement& place, Con
 	}
 }
 
-// ------------------------------------------------------------------------------------------------
-void GetAbsTransform(aiMatrix4x4& out, const aiNode* nd, ConversionData& conv)
-{
-	aiMatrix4x4 t;
-	if (nd->mParent) {
-		GetAbsTransform(t,nd->mParent,conv);
-	}
-	out = t*nd->mTransformation;
-}
-
 // ------------------------------------------------------------------------------------------------
 bool ProcessMappedItem(const IfcMappedItem& mapped, aiNode* nd_src, std::vector< aiNode* >& subnodes_src, unsigned int matid, ConversionData& conv)
 {
@@ -682,14 +670,14 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion
 	// skip over space and annotation nodes - usually, these have no meaning in Assimp's context
 	bool skipGeometry = false;
 	if(conv.settings.skipSpaceRepresentations) {
-		if(const IfcSpace* const space = el.ToPtr<IfcSpace>()) {
+		if(el.ToPtr<IfcSpace>()) {
 			IFCImporter::LogDebug("skipping IfcSpace entity due to importer settings");
 			skipGeometry = true;
 		}
 	}
 
 	if(conv.settings.skipAnnotations) {
-		if(const IfcAnnotation* const ann = el.ToPtr<IfcAnnotation>()) {
+		if(el.ToPtr<IfcAnnotation>()) {
 			IFCImporter::LogDebug("skipping IfcAnnotation entity due to importer settings");
 			return NULL;
 		}
@@ -764,7 +752,7 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion
 					continue;
 				}
 				BOOST_FOREACH(const IfcProduct& pro, cont->RelatedElements) {		
-					if(const IfcOpeningElement* const open = pro.ToPtr<IfcOpeningElement>()) {
+					if(pro.ToPtr<IfcOpeningElement>()) {
 						// IfcOpeningElement is handled below. Sadly we can't use it here as is:
 						// The docs say that opening elements are USUALLY attached to building storey,
 						// but we want them for the building elements to which they belong.

code/IFCProfile.cpp

@@ -114,7 +114,7 @@ void ProcessParametrizedProfile(const IfcParameterizedProfileDef& def, TempMesh&
 		meshout.vertcnt.push_back(4);
 	}
 	else if( const IfcCircleProfileDef* const circle = def.ToPtr<IfcCircleProfileDef>()) {
-		if( const IfcCircleHollowProfileDef* const hollow = def.ToPtr<IfcCircleHollowProfileDef>()) {
+		if(def.ToPtr<IfcCircleHollowProfileDef>()) {
 			// TODO
 		}
 		const size_t segments = 32;

code/IRRLoader.cpp

@@ -194,7 +194,7 @@ void IRRImporter::BuildSkybox(std::vector<aiMesh*>& meshes, std::vector<aiMateri
 		aiMaterial* out = ( aiMaterial* ) (*(materials.end()-(6-i)));
 
 		aiString s;
-		s.length = ::sprintf( s.data, "SkyboxSide_%i",i );
+		s.length = ::sprintf( s.data, "SkyboxSide_%u",i );
 		out->AddProperty(&s,AI_MATKEY_NAME);
 
 		int shading = aiShadingMode_NoShading;

code/ImproveCacheLocality.cpp

@@ -110,7 +110,7 @@ void ImproveCacheLocalityProcess::Execute( aiScene* pScene)
 	}
 	if (!DefaultLogger::isNullLogger()) {
 		char szBuff[128]; // should be sufficiently large in every case
-		::sprintf(szBuff,"Cache relevant are %i meshes (%i faces). Average output ACMR is %f",
+		::sprintf(szBuff,"Cache relevant are %u meshes (%u faces). Average output ACMR is %f",
 			numm,numf,out/numf);
 
 		DefaultLogger::get()->info(szBuff);
@@ -182,7 +182,7 @@ float ImproveCacheLocalityProcess::ProcessMesh( aiMesh* pMesh, unsigned int mesh
 			// the JoinIdenticalVertices process has not been executed on this
 			// mesh, otherwise this value would normally be at least minimally
 			// smaller than 3.0 ...
-			sprintf(szBuff,"Mesh %i: Not suitable for vcache optimization",meshNum);
+			sprintf(szBuff,"Mesh %u: Not suitable for vcache optimization",meshNum);
 			DefaultLogger::get()->warn(szBuff);
 			return 0.f;
 		}
@@ -361,7 +361,7 @@ float ImproveCacheLocalityProcess::ProcessMesh( aiMesh* pMesh, unsigned int mesh
 		if ( DefaultLogger::get()->getLogSeverity() == Logger::VERBOSE) {
 			char szBuff[128]; // should be sufficiently large in every case
 
-			::sprintf(szBuff,"Mesh %i | ACMR in: %f out: %f | ~%.1f%%",meshNum,fACMR,fACMR2,
+			::sprintf(szBuff,"Mesh %u | ACMR in: %f out: %f | ~%.1f%%",meshNum,fACMR,fACMR2,
 				((fACMR - fACMR2) / fACMR) * 100.f);
 			DefaultLogger::get()->debug(szBuff);
 		}

code/LWOLoader.cpp

@@ -209,7 +209,7 @@ void LWOImporter::InternReadFile( const std::string& pFile,
 		// we need to check now whether the requested layer has been found.
 		if (UINT_MAX != configLayerIndex) {
 			unsigned int layerCount = 0;
-			for(std::list<LWO::Layer>::iterator itLayers=mLayers->begin(); itLayers!=mLayers->end(); itLayers++)
+			for(std::list<LWO::Layer>::iterator itLayers=mLayers->begin(); itLayers!=mLayers->end(); ++itLayers)
 				if (!itLayers->skip)
 					layerCount++;
 			if (layerCount!=2)

code/LWSLoader.cpp

@@ -450,7 +450,7 @@ void LWSImporter::BuildGraph(aiNode* nd, LWS::NodeDesc& src, std::vector<Attachm
 	}
 
 	// Add children
-	if (src.children.size()) {
+	if (!src.children.empty()) {
 		nd->mChildren = new aiNode*[src.children.size()];
 		for (std::list<LWS::NodeDesc*>::iterator it = src.children.begin(); it != src.children.end(); ++it) {
 			aiNode* ndd = nd->mChildren[nd->mNumChildren++] = new aiNode();

code/LimitBoneWeightsProcess.cpp

@@ -193,7 +193,7 @@ void LimitBoneWeightsProcess::ProcessMesh( aiMesh* pMesh)
 
 		if (!DefaultLogger::isNullLogger()) {
 			char buffer[1024];
-			::sprintf(buffer,"Removed %i weights. Input bones: %i. Output bones: %i",removed,old_bones,pMesh->mNumBones);
+			::sprintf(buffer,"Removed %u weights. Input bones: %u. Output bones: %u",removed,old_bones,pMesh->mNumBones);
 			DefaultLogger::get()->info(buffer);
 		}
 	}

code/MD3Loader.cpp

@@ -791,7 +791,7 @@ void MD3Importer::InternReadFile( const std::string& pFile,
 
 	// Adjust all texture paths in the shader
 	const char* header_name = pcHeader->NAME;
-	if (shaders.blocks.size()) {
+	if (!shaders.blocks.empty()) {
 		for (std::list< Q3Shader::ShaderDataBlock >::iterator dit = shaders.blocks.begin(); dit != shaders.blocks.end(); ++dit) {
 			ConvertPath((*dit).name.c_str(),header_name,(*dit).name);
 
@@ -881,7 +881,7 @@ void MD3Importer::InternReadFile( const std::string& pFile,
 
 		// Now search the current shader for a record with this name (
 		// excluding texture file extension)
-		if (shaders.blocks.size()) {
+		if (!shaders.blocks.empty()) {
 
 			std::string::size_type s = convertedPath.find_last_of('.');
 			if (s == std::string::npos)

code/MD5Parser.cpp

@@ -95,7 +95,7 @@ MD5Parser::MD5Parser(char* _buffer, unsigned int _fileSize )
 /*static*/ AI_WONT_RETURN void MD5Parser::ReportError (const char* error, unsigned int line)
 {
 	char szBuffer[1024];
-	::sprintf(szBuffer,"[MD5] Line %i: %s",line,error);
+	::sprintf(szBuffer,"[MD5] Line %u: %s",line,error);
 	throw DeadlyImportError(szBuffer);
 }
 
@@ -104,7 +104,7 @@ MD5Parser::MD5Parser(char* _buffer, unsigned int _fileSize )
 /*static*/ void MD5Parser::ReportWarning (const char* warn, unsigned int line)
 {
 	char szBuffer[1024]; 
-	::sprintf(szBuffer,"[MD5] Line %i: %s",line,warn);
+	::sprintf(szBuffer,"[MD5] Line %u: %s",line,warn);
 	DefaultLogger::get()->warn(szBuffer);
 }
 

code/MDLLoader.cpp

@@ -264,7 +264,7 @@ void MDLImporter::SizeCheck(const void* szPos, const char* szFile, unsigned int
 
 		char szBuffer[1024];
 		::sprintf(szBuffer,"Invalid MDL file. The file is too small "
-			"or contains invalid data (File: %s Line: %i)",szFilePtr,iLine);
+			"or contains invalid data (File: %s Line: %u)",szFilePtr,iLine);
 
 		throw DeadlyImportError(szBuffer);
 	}
@@ -1536,7 +1536,7 @@ void MDLImporter::InternReadFile_3DGS_MDL7( )
 			// setup the name of the node
 			char* const szBuffer = &aszGroupNameBuffer[i*AI_MDL7_MAX_GROUPNAMESIZE];
 			if ('\0' == *szBuffer)
-				pcNode->mName.length = ::sprintf(szBuffer,"Group_%i",p);
+				pcNode->mName.length = ::sprintf(szBuffer,"Group_%u",p);
 			else pcNode->mName.length = ::strlen(szBuffer);
 			::strcpy(pcNode->mName.data,szBuffer);
 			++p;

code/MS3DLoader.cpp

@@ -531,7 +531,7 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
 		}
 
 		// allocate storage for bones
-		if(mybones.size()) {
+		if(!mybones.empty()) {
 			std::vector<unsigned int> bmap(joints.size());
 			m->mBones = new aiBone*[mybones.size()]();
 			for(BoneSet::const_iterator it = mybones.begin(); it != mybones.end(); ++it) {

code/NFFLoader.cpp

@@ -1115,7 +1115,7 @@ void NFFImporter::InternReadFile( const std::string& pFile,
 			aiNode* nd = *ppcChildren  = new aiNode();
 			nd->mParent = root;
 
-			nd->mName.length = ::sprintf(nd->mName.data,"<NFF_Light%i>",i);
+			nd->mName.length = ::sprintf(nd->mName.data,"<NFF_Light%u>",i);
 
 			// allocate the light in the scene data structure
 			aiLight* out = pScene->mLights[i] = new aiLight();

code/ObjExporter.cpp

@@ -288,7 +288,7 @@ int ObjExporter::vecIndexMap::getIndex(const aiVector3D& vec)
 void ObjExporter::vecIndexMap::getVectors( std::vector<aiVector3D>& vecs )
 {
 	vecs.resize(vecMap.size());
-	for(vecIndexMap::dataType::iterator it = vecMap.begin(); it != vecMap.end(); it++){
+	for(vecIndexMap::dataType::iterator it = vecMap.begin(); it != vecMap.end(); ++it){
 		vecs[it->second-1] = it->first;
 	}
 }

code/ObjFileMtlImporter.cpp

@@ -263,16 +263,21 @@ void ObjFileMtlImporter::createMaterial()
     }
     
     std::vector<std::string> token;
-    const unsigned int numToken = tokenize<std::string>( line, token, " " );
+    const unsigned int numToken = tokenize<std::string>( line, token, " \t" );
-    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 ];
+		// skip newmtl and all following white spaces
-    }
+		std::size_t first_ws_pos = line.find_first_of(" \t");
+		std::size_t first_non_ws_pos = line.find_first_not_of(" \t", first_ws_pos);
+		if (first_non_ws_pos != std::string::npos) {
+			name = line.substr(first_non_ws_pos);
+		}
+	}
 
-    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
         m_pModel->m_pCurrentMaterial = new ObjFile::Material();	
         m_pModel->m_pCurrentMaterial->MaterialName.Set( name );

code/ObjFileParser.cpp

@@ -469,7 +469,7 @@ void ObjFileParser::getMaterialDesc()
         return;
 
     char *pStart = &(*m_DataIt);
-    while( m_DataIt != m_DataItEnd && !IsSpaceOrNewLine( *m_DataIt ) ) {
+    while( m_DataIt != m_DataItEnd && !IsLineEnd( *m_DataIt ) ) {
         ++m_DataIt;
     }
 

code/ObjFileParser.h

@@ -122,6 +122,11 @@ private:
     void reportErrorTokenInFace();
 
 private:
+	// Copy and assignment constructor should be private 
+	// because the class contains pointer to allocated memory
+    ObjFileParser(const ObjFileParser& rhs);
+	ObjFileParser& operator=(const ObjFileParser& rhs);
+
     ///	Default material name
     static const std::string DEFAULT_MATERIAL;
     //!	Iterator to current position in buffer

code/OgreImporter.h

@@ -81,7 +81,7 @@ private:
 	void AssignMaterials(aiScene *pScene, std::vector<aiMaterial*> &materials);
 	
 	/// Reads material
-	aiMaterial* ReadMaterial(const std::string &pFile, Assimp::IOSystem *pIOHandler, const std::string MaterialName);
+	aiMaterial* ReadMaterial(const std::string &pFile, Assimp::IOSystem *pIOHandler, const std::string &MaterialName);
 
 	// These functions parse blocks from a material file from @c ss. Starting parsing from "{" and ending it to "}".
 	bool ReadTechnique(const std::string &techniqueName, std::stringstream &ss, aiMaterial *material);

code/OgreMaterial.cpp

@@ -120,7 +120,7 @@ void OgreImporter::AssignMaterials(aiScene *pScene, std::vector<aiMaterial*> &ma
 	}
 }
 
-aiMaterial* OgreImporter::ReadMaterial(const std::string &pFile, Assimp::IOSystem *pIOHandler, const std::string materialName)
+aiMaterial* OgreImporter::ReadMaterial(const std::string &pFile, Assimp::IOSystem *pIOHandler, const std::string &materialName)
 {
 	if (materialName.empty()) {
 		return 0;

code/OpenGEXImporter.cpp

@@ -47,6 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/scene.h>
 #include <assimp/ai_assert.h>
 
+#include <algorithm>
 #include <vector>
 
 static const aiImporterDesc desc = {
@@ -84,6 +85,14 @@ namespace Grammar {
     static const std::string SpecularColorToken = "specular";
     static const std::string EmissionColorToken = "emission";
     
+    static const std::string DiffuseTextureToken = "diffuse";
+    static const std::string DiffuseSpecularTextureToken = "specular";
+    static const std::string SpecularPowerTextureToken = "specular_power";
+    static const std::string EmissionTextureToken = "emission";
+    static const std::string OpacyTextureToken = "opacity";
+    static const std::string TransparencyTextureToken = "transparency";
+    static const std::string NormalTextureToken = "normal";
+
     static const char *TextureType         = "Texture";
 
     enum TokenType {
@@ -183,12 +192,11 @@ USE_ODDLPARSER_NS
 //------------------------------------------------------------------------------------------------
 OpenGEXImporter::VertexContainer::VertexContainer()
 : m_numVerts( 0 )
-, m_vertices()
+, m_vertices(NULL)
 , m_numNormals( 0 )
-, m_normals()
+, m_normals(NULL) {
-, m_textureCoords()
+    std::fill(&m_numUVComps[0], &m_numUVComps[AI_MAX_NUMBER_OF_TEXTURECOORDS], 0U);
-, m_numUVComps() {
+    std::fill(&m_textureCoords[0], &m_textureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS], static_cast<aiVector3D *>(NULL));
-    // empty
 }
 
 //------------------------------------------------------------------------------------------------
@@ -215,17 +223,18 @@ OpenGEXImporter::RefInfo::~RefInfo() {
 
 //------------------------------------------------------------------------------------------------
 OpenGEXImporter::OpenGEXImporter() 
-: m_meshCache()
+: m_root( NULL )
-, m_root( NULL )
 , m_nodeChildMap()
+, m_meshCache()
 , m_mesh2refMap()
 , m_ctx( NULL )
 , m_currentNode( NULL )
 , m_currentMesh( NULL )
 , m_currentMaterial( NULL )
+, m_tokenType( Grammar::NoneType )
 , m_nodeStack()
 , m_unresolvedRefStack() {
-    // empty
+    std::fill(&m_metrics[0], &m_metrics[MetricInfo::Max], MetricInfo());
 }
 
 //------------------------------------------------------------------------------------------------
@@ -291,7 +300,7 @@ void OpenGEXImporter::handleNodes( DDLNode *node, aiScene *pScene ) {
     }
 
     DDLNode::DllNodeList childs = node->getChildNodeList();
-    for( DDLNode::DllNodeList::iterator it = childs.begin(); it != childs.end(); it++ ) {
+    for( DDLNode::DllNodeList::iterator it = childs.begin(); it != childs.end(); ++it ) {
         Grammar::TokenType tokenType( Grammar::matchTokenType( ( *it )->getType().c_str() ) );
         switch( tokenType ) {
             case Grammar::MetricToken:
@@ -406,7 +415,12 @@ void OpenGEXImporter::handleNameNode( DDLNode *node, aiScene *pScene ) {
         }
 
         const std::string name( val->getString() );
-        m_currentNode->mName.Set( name.c_str() );
+        if( m_tokenType == Grammar::GeometryNodeToken ) {
+            m_currentNode->mName.Set( name.c_str() );
+        } else if( m_tokenType == Grammar::MaterialToken ) {
+            
+        }
+
     }
 }
 
@@ -462,6 +476,7 @@ void OpenGEXImporter::handleMaterialRefNode( ODDLParser::DDLNode *node, aiScene
 void OpenGEXImporter::handleGeometryNode( DDLNode *node, aiScene *pScene ) {
     aiNode *newNode = new aiNode;
     pushNode( newNode, pScene );
+    m_tokenType = Grammar::GeometryNodeToken;
     m_currentNode = newNode;
     handleNodes( node, pScene );
     
@@ -489,24 +504,25 @@ static void setMatrix( aiNode *node, DataArrayList *transformData ) {
     }
     
     node->mTransformation.a1 = m[ 0 ];
-    node->mTransformation.a2 = m[ 1 ];
+    node->mTransformation.a2 = m[ 4 ];
-    node->mTransformation.a3 = m[ 2 ];
+    node->mTransformation.a3 = m[ 8 ];
-    node->mTransformation.a4 = m[ 3 ];
+    node->mTransformation.a4 = m[ 12 ];
 
-    node->mTransformation.b1 = m[ 4 ];
+    node->mTransformation.b1 = m[ 1 ];
     node->mTransformation.b2 = m[ 5 ];
-    node->mTransformation.b3 = m[ 6 ];
+    node->mTransformation.b3 = m[ 9 ];
-    node->mTransformation.b4 = m[ 7 ];
+    node->mTransformation.b4 = m[ 13 ];
 
-    node->mTransformation.c1 = m[ 8 ];
+    node->mTransformation.c1 = m[ 2 ];
-    node->mTransformation.c2 = m[ 9 ];
+    node->mTransformation.c2 = m[ 6 ];
     node->mTransformation.c3 = m[ 10 ];
-    node->mTransformation.c4 = m[ 11 ];
+    node->mTransformation.c4 = m[ 14 ];
 
-    node->mTransformation.d1 = m[ 12 ];
+    node->mTransformation.d1 = m[ 3 ];
-    node->mTransformation.d2 = m[ 13 ];
+    node->mTransformation.d2 = m[ 7 ];
-    node->mTransformation.d3 = m[ 14 ];
+    node->mTransformation.d3 = m[ 11 ];
     node->mTransformation.d4 = m[ 15 ];
+
 }
 
 //------------------------------------------------------------------------------------------------
@@ -658,7 +674,6 @@ void OpenGEXImporter::handleVertexArrayNode( ODDLParser::DDLNode *node, aiScene
         }
 
         const size_t numItems( countDataArrayListItems( vaList ) );
-        Value *next( vaList->m_dataList );
         if( Position == attribType ) {
             m_currentVertices.m_numVerts = numItems;
             m_currentVertices.m_vertices = new aiVector3D[ numItems ];
@@ -768,9 +783,8 @@ static ColorType getColorType( Identifier *id ) {
 void OpenGEXImporter::handleMaterialNode( ODDLParser::DDLNode *node, aiScene *pScene ) {
     m_currentMaterial = new aiMaterial;
     m_materialCache.push_back( m_currentMaterial );
-
+    m_tokenType = Grammar::MaterialToken;
     handleNodes( node, pScene );
-
 }
 
 //------------------------------------------------------------------------------------------------
@@ -802,7 +816,41 @@ void OpenGEXImporter::handleColorNode( ODDLParser::DDLNode *node, aiScene *pScen
 
 //------------------------------------------------------------------------------------------------
 void OpenGEXImporter::handleTextureNode( ODDLParser::DDLNode *node, aiScene *pScene ) {
+    if( NULL == node ) {
+        return;
+    }
 
+    Property *prop = node->findPropertyByName( "attrib" );
+    if( NULL != prop ) {
+        if( NULL != prop->m_value ) {
+            Value *val( node->getValue() );
+            if( NULL != val ) {
+                aiString tex;
+                tex.Set( val->getString() );
+                if( prop->m_value->getString() == Grammar::DiffuseTextureToken ) {
+                    m_currentMaterial->AddProperty( &tex, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) );
+                } else if( prop->m_value->getString() == Grammar::SpecularPowerTextureToken ) {
+                    m_currentMaterial->AddProperty( &tex, AI_MATKEY_TEXTURE_SPECULAR( 0 ) );
+
+                } else if( prop->m_value->getString() == Grammar::EmissionTextureToken ) {
+                    m_currentMaterial->AddProperty( &tex, AI_MATKEY_TEXTURE_EMISSIVE( 0 ) );
+
+                } else if( prop->m_value->getString() == Grammar::OpacyTextureToken ) {
+                    m_currentMaterial->AddProperty( &tex, AI_MATKEY_TEXTURE_OPACITY( 0 ) );
+
+                } else if( prop->m_value->getString() == Grammar::TransparencyTextureToken ) {
+                    // ToDo!
+                    // m_currentMaterial->AddProperty( &tex, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) );
+                } else if( prop->m_value->getString() == Grammar::NormalTextureToken ) {
+                    m_currentMaterial->AddProperty( &tex, AI_MATKEY_TEXTURE_NORMALS( 0 ) );
+
+                }
+                else {
+                    ai_assert( false );
+                }
+            }
+        }
+    }
 }
 
 //------------------------------------------------------------------------------------------------

code/OpenGEXImporter.h

@@ -179,6 +179,7 @@ private:
     VertexContainer m_currentVertices;
     aiMesh *m_currentMesh;
     aiMaterial *m_currentMaterial;
+    int m_tokenType;
     std::vector<aiMaterial*> m_materialCache;
     std::vector<aiNode*> m_nodeStack;
     std::vector<RefInfo*> m_unresolvedRefStack;

code/OptimizeGraph.cpp

@@ -71,6 +71,10 @@ using namespace Assimp;
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 OptimizeGraphProcess::OptimizeGraphProcess()
+    : mScene()
+    , nodes_in()
+    , nodes_out()
+    , count_merged()
 {}
 
 // ------------------------------------------------------------------------------------------------
@@ -122,7 +126,7 @@ void OptimizeGraphProcess::CollectNewChildren(aiNode* nd, std::list<aiNode*>& no
 			++it;
 		}
 
-		if (nd->mNumMeshes || child_nodes.size()) { 
+		if (nd->mNumMeshes || !child_nodes.empty()) { 
 			nodes.push_back(nd);
 		}
 		else {
@@ -172,7 +176,7 @@ void OptimizeGraphProcess::CollectNewChildren(aiNode* nd, std::list<aiNode*>& no
 			}
 			++it;
 		}
-		if (join_master && join.size()) {
+		if (join_master && !join.empty()) {
 			join_master->mName.length = sprintf(join_master->mName.data,"$MergedNode_%i",count_merged++);
 
 			unsigned int out_meshes = 0;
@@ -221,7 +225,7 @@ void OptimizeGraphProcess::CollectNewChildren(aiNode* nd, std::list<aiNode*>& no
 
 		delete[] nd->mChildren;
 
-		if (child_nodes.size())
+		if (!child_nodes.empty())
 			nd->mChildren = new aiNode*[child_nodes.size()];
 		else nd->mChildren = NULL;
 	}
@@ -331,7 +335,7 @@ void OptimizeGraphProcess::Execute( aiScene* pScene)
 		if ( nodes_in != nodes_out) {
 
 			char buf[512];
-			sprintf(buf,"OptimizeGraphProcess finished; Input nodes: %i, Output nodes: %i",nodes_in,nodes_out);
+			sprintf(buf,"OptimizeGraphProcess finished; Input nodes: %u, Output nodes: %u",nodes_in,nodes_out);
 			DefaultLogger::get()->info(buf);
 		}
 		else DefaultLogger::get()->debug("OptimizeGraphProcess finished");

code/OptimizeMeshes.cpp

@@ -60,9 +60,10 @@ static const unsigned int DeadBeef = 0xdeadbeef;
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 OptimizeMeshesProcess::OptimizeMeshesProcess()
-: pts (false)
+    : mScene()
-, max_verts( NotSet )
+    , pts(false)
-, max_faces( NotSet ) {
+    , max_verts( NotSet )
+    , max_faces( NotSet ) {
     // empty
 }
 
@@ -149,7 +150,7 @@ void OptimizeMeshesProcess::Execute( aiScene* pScene)
 
 	if (output.size() != num_old) {
 		char tmp[512];
-		::sprintf(tmp,"OptimizeMeshesProcess finished. Input meshes: %i, Output meshes: %i",num_old,pScene->mNumMeshes);
+		::sprintf(tmp,"OptimizeMeshesProcess finished. Input meshes: %u, Output meshes: %u",num_old,pScene->mNumMeshes);
 		DefaultLogger::get()->info(tmp);
     } else {
         DefaultLogger::get()->debug( "OptimizeMeshesProcess finished" );

code/OptimizeMeshes.h

@@ -164,9 +164,6 @@ private:
 	//! Per mesh info
 	std::vector<MeshInfo> meshes;
 
-	//! Next output mesh
-	aiMesh* mesh;
-
 	//! Output meshes
 	std::vector<aiMesh*> output;
 

code/PlyExporter.cpp

@@ -96,7 +96,6 @@ void ExportScenePlyBinary(const char* pFile, IOSystem* pIOSystem, const aiScene*
 // ------------------------------------------------------------------------------------------------
 PlyExporter::PlyExporter(const char* _filename, const aiScene* pScene, bool binary)
 : filename(_filename)
-, pScene(pScene)
 , endl("\n")
 {
 	// make sure that all formatting happens using the standard, C locale and not the user's current locale

code/PlyExporter.h

@@ -78,7 +78,6 @@ private:
 private:
 
 	const std::string filename;
-	const aiScene* const pScene;
 
 	// obviously, this endl() doesn't flush() the stream 
 	const std::string endl;

code/PretransformVertices.cpp

@@ -644,7 +644,7 @@ void PretransformVertices::Execute( aiScene* pScene)
 			{
 				aiNode* pcNode = *nodes = new aiNode();
 				pcNode->mParent = pScene->mRootNode;
-				pcNode->mName.length = ::sprintf(pcNode->mName.data,"mesh_%i",i);
+				pcNode->mName.length = ::sprintf(pcNode->mName.data,"mesh_%u",i);
 
 				// setup mesh indices
 				pcNode->mNumMeshes = 1;
@@ -656,7 +656,7 @@ void PretransformVertices::Execute( aiScene* pScene)
 			{
 				aiNode* pcNode = *nodes = new aiNode();
 				pcNode->mParent = pScene->mRootNode;
-				pcNode->mName.length = ::sprintf(pcNode->mName.data,"light_%i",i);
+				pcNode->mName.length = ::sprintf(pcNode->mName.data,"light_%u",i);
 				pScene->mLights[i]->mName = pcNode->mName;
 			}
 			// generate camera nodes
@@ -664,7 +664,7 @@ void PretransformVertices::Execute( aiScene* pScene)
 			{
 				aiNode* pcNode = *nodes = new aiNode();
 				pcNode->mParent = pScene->mRootNode;
-				pcNode->mName.length = ::sprintf(pcNode->mName.data,"cam_%i",i);
+				pcNode->mName.length = ::sprintf(pcNode->mName.data,"cam_%u",i);
 				pScene->mCameras[i]->mName = pcNode->mName;
 			}
 		}
@@ -707,15 +707,15 @@ void PretransformVertices::Execute( aiScene* pScene)
 
 		DefaultLogger::get()->debug("PretransformVerticesProcess finished");
 
-		sprintf(buffer,"Removed %i nodes and %i animation channels (%i output nodes)",
+		sprintf(buffer,"Removed %u nodes and %u animation channels (%u output nodes)",
 			iOldNodes,iOldAnimationChannels,CountNodes(pScene->mRootNode));
 		DefaultLogger::get()->info(buffer);
 
-		sprintf(buffer,"Kept %i lights and %i cameras",
+		sprintf(buffer,"Kept %u lights and %u cameras",
 			pScene->mNumLights,pScene->mNumCameras);
 		DefaultLogger::get()->info(buffer);
 
-		sprintf(buffer,"Moved %i meshes to WCS (number of output meshes: %i)",
+		sprintf(buffer,"Moved %u meshes to WCS (number of output meshes: %u)",
 			iOldMeshes,pScene->mNumMeshes);
 		DefaultLogger::get()->info(buffer);
 	}

code/RemoveRedundantMaterials.cpp

@@ -180,7 +180,7 @@ void RemoveRedundantMatsProcess::Execute( aiScene* pScene)
 				if (ppcMaterials[idx]) 
 				{
 					aiString sz;
-					sz.length = ::sprintf(sz.data,"JoinedMaterial_#%i",p);
+					sz.length = ::sprintf(sz.data,"JoinedMaterial_#%u",p);
 					((aiMaterial*)ppcMaterials[idx])->AddProperty(&sz,AI_MATKEY_NAME);
 				}
 				else
@@ -207,7 +207,7 @@ void RemoveRedundantMatsProcess::Execute( aiScene* pScene)
 	else 
 	{
 		char szBuffer[128]; // should be sufficiently large
-		::sprintf(szBuffer,"RemoveRedundantMatsProcess finished. Removed %i redundant and %i unused materials.",
+		::sprintf(szBuffer,"RemoveRedundantMatsProcess finished. Removed %u redundant and %u unused materials.",
 			redundantRemoved,unreferencedRemoved);
 		DefaultLogger::get()->info(szBuffer);
 	}

code/RemoveVCProcess.cpp

@@ -54,7 +54,9 @@ using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-RemoveVCProcess::RemoveVCProcess()
+RemoveVCProcess::RemoveVCProcess() :
+    configDeleteFlags()
+  , mScene()
 {}
 
 // ------------------------------------------------------------------------------------------------

code/SMDLoader.cpp

@@ -208,7 +208,7 @@ void SMDImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
 void SMDImporter::LogErrorNoThrow(const char* msg)
 {
 	char szTemp[1024];
-	sprintf(szTemp,"Line %i: %s",iLineNumber,msg);
+	sprintf(szTemp,"Line %u: %s",iLineNumber,msg);
 	DefaultLogger::get()->error(szTemp);
 }
 
@@ -218,7 +218,7 @@ void SMDImporter::LogWarning(const char* msg)
 {
 	char szTemp[1024];
 	ai_assert(strlen(msg) < 1000);
-	sprintf(szTemp,"Line %i: %s",iLineNumber,msg);
+	sprintf(szTemp,"Line %u: %s",iLineNumber,msg);
 	DefaultLogger::get()->warn(szTemp);
 }
 
@@ -647,7 +647,7 @@ void SMDImporter::CreateOutputMaterials()
 		pScene->mMaterials[iMat] = pcMat;
 
 		aiString szName;
-		szName.length = (size_t)::sprintf(szName.data,"Texture_%i",iMat);
+		szName.length = (size_t)::sprintf(szName.data,"Texture_%u",iMat);
 		pcMat->AddProperty(&szName,AI_MATKEY_NAME);
 
 		if (aszTextures[iMat].length())

code/STEPFileReader.cpp

@@ -55,28 +55,6 @@ namespace EXPRESS = STEP::EXPRESS;
 
 #include <functional>
 
-// ------------------------------------------------------------------------------------------------
-// From http://stackoverflow.com/questions/216823/whats-the-best-way-to-trim-stdstring
-
-// trim from start
-static inline std::string &ltrim(std::string &s) {
-	s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1( std::ptr_fun(Assimp::IsSpace<char>))));
-	return s;
-}
-
-// trim from end
-static inline std::string &rtrim(std::string &s) {
-	s.erase(std::find_if(s.rbegin(), s.rend(), std::not1( std::ptr_fun(Assimp::IsSpace<char>))).base(),s.end());
-	return s;
-}
-// trim from both ends
-static inline std::string &trim(std::string &s) {
-	return ltrim(rtrim(s));
-}
-
-
-
-
 // ------------------------------------------------------------------------------------------------
 std::string AddLineNumber(const std::string& s,uint64_t line /*= LINE_NOT_SPECIFIED*/, const std::string& prefix = "") 
 {

code/STLExporter.cpp

@@ -75,7 +75,7 @@ void ExportSceneSTLBinary(const char* pFile,IOSystem* pIOSystem, const aiScene*
 	STLExporter exporter(pFile, pScene, true);
 
 	// we're still here - export successfully completed. Write the file.
-	boost::scoped_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
+	boost::scoped_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wb"));
 	if(outfile == NULL) {
 		throw DeadlyExportError("could not open output .stl file: " + std::string(pFile));
 	}
@@ -89,7 +89,6 @@ void ExportSceneSTLBinary(const char* pFile,IOSystem* pIOSystem, const aiScene*
 // ------------------------------------------------------------------------------------------------
 STLExporter :: STLExporter(const char* _filename, const aiScene* pScene, bool binary)
 : filename(_filename)
-, pScene(pScene)
 , endl("\n")
 {
 	// make sure that all formatting happens using the standard, C locale and not the user's current locale

code/STLExporter.h

@@ -75,7 +75,6 @@ private:
 private:
 
 	const std::string filename;
-	const aiScene* const pScene;
 
 	// this endl() doesn't flush() the stream
 	const std::string endl;

code/SortByPTypeProcess.cpp

@@ -397,11 +397,11 @@ void SortByPTypeProcess::Execute( aiScene* pScene)
 	if (!DefaultLogger::isNullLogger())
 	{
 		char buffer[1024];
-		::sprintf(buffer,"Points: %i%s, Lines: %i%s, Triangles: %i%s, Polygons: %i%s (Meshes, X = removed)",
+		::sprintf(buffer,"Points: %u%s, Lines: %u%s, Triangles: %u%s, Polygons: %u%s (Meshes, X = removed)",
-			aiNumMeshesPerPType[0], (configRemoveMeshes & aiPrimitiveType_POINT     ? "X" : ""),
+			aiNumMeshesPerPType[0], ((configRemoveMeshes & aiPrimitiveType_POINT)     ? "X" : ""),
-			aiNumMeshesPerPType[1], (configRemoveMeshes & aiPrimitiveType_LINE      ? "X" : ""),
+			aiNumMeshesPerPType[1], ((configRemoveMeshes & aiPrimitiveType_LINE)      ? "X" : ""),
-			aiNumMeshesPerPType[2], (configRemoveMeshes & aiPrimitiveType_TRIANGLE  ? "X" : ""),
+			aiNumMeshesPerPType[2], ((configRemoveMeshes & aiPrimitiveType_TRIANGLE)  ? "X" : ""),
-			aiNumMeshesPerPType[3], (configRemoveMeshes & aiPrimitiveType_POLYGON   ? "X" : ""));
+			aiNumMeshesPerPType[3], ((configRemoveMeshes & aiPrimitiveType_POLYGON)   ? "X" : ""));
 		DefaultLogger::get()->info(buffer);
 		DefaultLogger::get()->debug("SortByPTypeProcess finished");
 	}

code/StepExporter.cpp

@@ -115,21 +115,6 @@ void ExportSceneStep(const char* pFile,IOSystem* pIOSystem, const aiScene* pScen
 
 
 namespace {
-	inline uint64_t toIndexHash(int32_t id1, int32_t id2)
-	{
-		// dont wonder that -1/-1 -> hash=-1
-		uint64_t hash = (uint32_t) id1;
-		hash = (hash << 32);
-		hash += (uint32_t) id2;
-		return hash;
-	}
-
-	inline void fromIndexHash(uint64_t hash, int32_t &id1, int32_t &id2)
-	{
-		id1 = (hash & 0xFFFFFFFF00000000) >> 32;
-		id2 = (hash & 0xFFFFFFFF);
-	}
-
 	// Collect world transformations for each node
 	void CollectTrafos(const aiNode* node, std::map<const aiNode*, aiMatrix4x4>& trafos) {
 		const aiMatrix4x4& parent = node->mParent ? trafos[node->mParent] : aiMatrix4x4();
@@ -152,7 +137,7 @@ namespace {
 
 // ------------------------------------------------------------------------------------------------
 // Constructor for a specific scene to export
-StepExporter::StepExporter(const aiScene* pScene, IOSystem* pIOSystem, const std::string& path, const std::string& file, const ExportProperties* pProperties) : mIOSystem(pIOSystem), mPath(path), mFile(file), mProperties(pProperties)
+StepExporter::StepExporter(const aiScene* pScene, IOSystem* pIOSystem, const std::string& path, const std::string& file, const ExportProperties* pProperties) : mProperties(pProperties), mIOSystem(pIOSystem), mFile(file), mPath(path), mScene(pScene), endstr(";\n")
 {
 	CollectTrafos(pScene->mRootNode, trafos);
 	CollectMeshes(pScene->mRootNode, meshes);
@@ -160,11 +145,6 @@ StepExporter::StepExporter(const aiScene* pScene, IOSystem* pIOSystem, const std
 	// make sure that all formatting happens using the standard, C locale and not the user's current locale
 	mOutput.imbue( std::locale("C") );
 
-	mScene = pScene;
-
-	// set up strings
-	endstr = ";\n";
-
 	// start writing
 	WriteFile();
 }
@@ -271,7 +251,7 @@ void StepExporter::WriteFile()
 	mOutput << "))" << endstr;
 
 	// write all the unique transformed CARTESIAN and VERTEX
-	for (MeshesByNodeMap::const_iterator it2 = meshes.begin(); it2 != meshes.end(); it2++)
+	for (MeshesByNodeMap::const_iterator it2 = meshes.begin(); it2 != meshes.end(); ++it2)
 	{
 		const aiNode& node = *(*it2).first;
 		unsigned int mesh_idx = (*it2).second;

code/TextureTransform.cpp

@@ -54,7 +54,8 @@ using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-TextureTransformStep::TextureTransformStep()
+TextureTransformStep::TextureTransformStep() :
+    configFlags()
 {
 	// nothing to do here
 }

code/UnrealLoader.cpp

@@ -377,7 +377,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
 		aiColor3D color(1.f,1.f,1.f);
 
 		aiString s;
-		::sprintf(s.data,"mat%i_tx%i_",i,materials[i].tex);
+		::sprintf(s.data,"mat%u_tx%u_",i,materials[i].tex);
 
 		// set the two-sided flag
 		if (materials[i].type == Unreal::MF_NORMAL_TS) {

code/ValidateDataStructure.cpp

@@ -60,7 +60,8 @@ using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-ValidateDSProcess::ValidateDSProcess()
+ValidateDSProcess::ValidateDSProcess() :
+    mScene()
 {}
 
 // ------------------------------------------------------------------------------------------------
@@ -690,8 +691,7 @@ void ValidateDSProcess::Validate( const aiMaterial* pMaterial)
 		if (aiPTI_String == prop->mType)	{
 			// FIX: strings are now stored in a less expensive way, but we can't use the
 			// validation routine for 'normal' aiStrings
-			uint32_t len;
+			if (prop->mDataLength < 5 || prop->mDataLength < 4 + (*reinterpret_cast<uint32_t*>(prop->mData)) + 1)	{
-			if (prop->mDataLength < 5 || prop->mDataLength < 4 + (len=*reinterpret_cast<uint32_t*>(prop->mData)) + 1)	{
 				ReportError("aiMaterial::mProperties[%i].mDataLength is "
 					"too small to contain a string (%i, needed: %i)",
 					i,prop->mDataLength,sizeof(aiString));

code/XFileExporter.cpp

@@ -95,17 +95,18 @@ void ExportSceneXFile(const char* pFile,IOSystem* pIOSystem, const aiScene* pSce
 
 // ------------------------------------------------------------------------------------------------
 // Constructor for a specific scene to export
-XFileExporter::XFileExporter(const aiScene* pScene, IOSystem* pIOSystem, const std::string& path, const std::string& file, const ExportProperties* pProperties) : mIOSystem(pIOSystem), mPath(path), mFile(file), mProperties(pProperties)
+XFileExporter::XFileExporter(const aiScene* pScene, IOSystem* pIOSystem, const std::string& path, const std::string& file, const ExportProperties* pProperties)
+		: mProperties(pProperties),
+		mIOSystem(pIOSystem),
+		mPath(path),
+		mFile(file),
+		mScene(pScene),
+		mSceneOwned(false),
+		endstr("\n")
 {
 	// make sure that all formatting happens using the standard, C locale and not the user's current locale
 	mOutput.imbue( std::locale("C") );
 
-	mScene = pScene;
-	mSceneOwned = false;
-
-	// set up strings
-	endstr = "\n";
-
 	// start writing
 	WriteFile();
 }

code/assbin_chunks.h

@@ -47,7 +47,7 @@ in <tt>&lt;root&gt;/tools/assimp_cmd/WriteDumb.cpp</tt> (yes, the 'b' is no typo
 -------------------------------------------------------------------------------
 
 ----------------------
-| Header (500 bytes) |
+| Header (512 bytes) |
 ----------------------
 | Variable chunks    |
 ----------------------
@@ -100,11 +100,12 @@ byte[64]	Reserved for future use
 integer		Magic chunk ID (ASSBIN_CHUNK_XXX)
 integer		Chunk data length, in bytes 
                 (unknown chunks are possible, a good reader skips over them)
+                (chunk-data-length does not include the first two integers)
 
-byte[n]		length-of-chunk bytes of data, depending on the chunk type
+byte[n]		chunk-data-length bytes of data, depending on the chunk type
 
 Chunks can contain nested chunks. Nested chunks are ALWAYS at the end of the chunk,
-their size is included in length-of-chunk.
+their size is included in chunk-data-length.
 
 The chunk layout for all ASSIMP data structures is derived from their C declarations.
 The general 'rule' to get from Assimp headers to the serialized layout is:
@@ -133,14 +134,14 @@ The general 'rule' to get from Assimp headers to the serialized layout is:
 
    [number of used uv channels times]
        integer mNumUVComponents[n]
-       float mTextureCoords[n][mNumUVComponents[n]]
+       float mTextureCoords[n][3]
 
        -> more than AI_MAX_TEXCOORD_CHANNELS can be stored. This allows Assimp 
 	   builds with different settings for AI_MAX_TEXCOORD_CHANNELS to exchange
-	   data. Unlike the in-memory format, only the used components of the 
+	   data.
-	   UV coordinates are written to disk. If mNumUVComponents[0] is 1, the
+       -> the on-disk format always uses 3 floats to write UV coordinates.
-	   corresponding mTextureCoords array consists of mNumTextureCoords*1 
+	   If mNumUVComponents[0] is 1, the corresponding mTextureCoords array
-	   single floats.
+	   consists of 3 floats.
 
    - The array member block of aiMesh is prefixed with an integer that specifies 
      the kinds of vertex components actually present in the mesh. This is a 

contrib/openddlparser/code/Value.cpp

@@ -27,8 +27,42 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 BEGIN_ODDLPARSER_NS
 
-Value::Value()
+Value::Iterator::Iterator()
-: m_type( ddl_none )
+: m_start( ddl_nullptr )
+, m_current( ddl_nullptr ) {
+    // empty
+}
+
+Value::Iterator::Iterator( Value *start )
+: m_start( start )
+, m_current( start ) {
+    // empty
+}
+
+Value::Iterator::~Iterator() {
+    // empty
+}
+
+bool Value::Iterator::hasNext() const {
+    if( ddl_nullptr == m_current ) {
+        return false;
+    }
+    return ( ddl_nullptr != m_current->getNext() );
+}
+
+Value *Value::Iterator::getNext() {
+    if( !hasNext() ) {
+        return ddl_nullptr;
+    }
+
+    Value *v( m_current->getNext() );
+    m_current = v;
+
+    return v;
+}
+
+Value::Value( ValueType type )
+: m_type( type )
 , m_size( 0 )
 , m_data( ddl_nullptr )
 , m_next( ddl_nullptr ) {
@@ -46,7 +80,7 @@ void Value::setBool( bool value ) {
 
 bool Value::getBool() {
     assert( ddl_bool == m_type );
-    return ( bool ) ( *m_data );
+    return ( *m_data ) ? true : false;
 }
 
 void Value::setInt8( int8 value ) {
@@ -101,12 +135,11 @@ uint8 Value::getUnsignedInt8() const {
 void Value::setUnsignedInt16( uint16 value ) {
     assert( ddl_unsigned_int16 == m_type );
     ::memcpy( m_data, &value, m_size );
-
 }
+
 uint16 Value::getUnsignedInt16() const {
     assert( ddl_unsigned_int16 == m_type );
     return ( uint8 ) ( *m_data );
-
 }
 
 void Value::setUnsignedInt32( uint32 value ) {
@@ -135,9 +168,15 @@ void Value::setFloat( float value ) {
 }
 
 float Value::getFloat() const {
-    float v;
+    if( m_type == ddl_float ) {
-    ::memcpy( &v, m_data, m_size );
+        float v;
-    return v;
+        ::memcpy( &v, m_data, m_size );
+        return ( float ) v;
+    } else {
+        float tmp;
+        ::memcpy( &tmp, m_data, 4 );
+        return ( float ) tmp;
+    }
 }
 
 void Value::setDouble( double value ) {
@@ -225,7 +264,7 @@ Value *ValueAllocator::allocPrimData( Value::ValueType type, size_t len ) {
         return ddl_nullptr;
     }
 
-    Value *data = new Value;
+    Value *data = new Value( type );
     data->m_type = type;
     switch( type ) {
         case Value::ddl_bool:
@@ -241,7 +280,7 @@ Value *ValueAllocator::allocPrimData( Value::ValueType type, size_t len ) {
             data->m_size = sizeof( int );
             break;
         case Value::ddl_int64:
-            data->m_size = sizeof( long );
+            data->m_size = sizeof( int64 );
             break;
         case Value::ddl_unsigned_int8:
             data->m_size = sizeof( unsigned char );
@@ -250,7 +289,7 @@ Value *ValueAllocator::allocPrimData( Value::ValueType type, size_t len ) {
             data->m_size = sizeof( unsigned int );
             break;
         case Value::ddl_unsigned_int64:
-            data->m_size = sizeof( unsigned long );
+            data->m_size = sizeof( uint64 );
             break;
         case Value::ddl_half:
             data->m_size = sizeof( short );

contrib/openddlparser/include/openddlparser/DDLNode.h

@@ -21,8 +21,6 @@ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 -----------------------------------------------------------------------------------------------*/
 #pragma once
-#ifndef OPENDDLPARSER_DDLNODE_H_INC
-#define OPENDDLPARSER_DDLNODE_H_INC
 
 #include <openddlparser/OpenDDLCommon.h>
 
@@ -39,32 +37,104 @@ struct Reference;
 struct Property;
 struct DataArrayList;
 
+///
+/// @ingroup    OpenDDLParser
+///	@brief      This class represents one single instance in the object tree of the parsed OpenDDL-file.
+///
+/// A DDLNode represents one leaf in the OpenDDL-node tree. It can have one parent node and multiple children.
+/// You can assign special properties to a single DDLNode instance.
+///	A node instance can store values via a linked list. You can get the first value from the DDLNode.
+/// A node can store data-array-lists and references as well.
+///
 class DLL_ODDLPARSER_EXPORT DDLNode {
 public:
     friend class OpenDDLParser;
 
+    /// @brief  The child-node-list type.
     typedef std::vector<DDLNode*> DllNodeList;
 
 public:
+    ///	@brief  The class destructor.
     ~DDLNode();
+
+    ///	@brief  Will attach a parent node instance, an older one will be released.
+    /// @param  parent      [in] The parent node instance.
     void attachParent( DDLNode *parent );
+
+    /// @brief  Will try to detach a parent node instance, if there is any.
     void detachParent();
+
+    ///	@brief  Returns the assigned parent node instance, will return ddl_nullptr id no parent is assigned.
+    /// @return The parent node instance.
     DDLNode *getParent() const;
+
+    ///	@brief  Returns the child node list.
+    /// @return The list of child nodes.
     const DllNodeList &getChildNodeList() const;
-    void setType( const std::string &name );
+
+    /// Set the type of the DDLNode instance.
+    /// @param  type    [in] The type.
+    void setType( const std::string &type );
+
+    /// @brief  Returns the type of the DDLNode instance.
+    /// @return The type of the DDLNode instance.
     const std::string &getType() const;
+
+    /// Set the name of the DDLNode instance.
+    /// @param  type    [in] The name.
     void setName( const std::string &name );
+
+    /// @brief  Returns the name of the DDLNode instance.
+    /// @return The name of the DDLNode instance.
     const std::string &getName() const;
+
+    /// @brief  Set a new property set.
+    ///	@param  prop    [in] The first element of the property set.
     void setProperties( Property *prop );
+
+    ///	@brief  Returns the first element of the assigned property set.
+    ///	@return The first property of the assigned property set.
     Property *getProperties() const;
+
+    ///	@brief  Looks for a given property.
+    /// @param  name    [in] The name for the property to look for.
+    /// @return true, if a corresponding property is assigned to the node, false if not.
     bool hasProperty( const std::string &name );
+
+    ///	@brief  Search for a given property and returns it. Will return ddl_nullptr if no property was found.
+    /// @param  name    [in] The name for the property to look for.
+    /// @return The property or ddl_nullptr if no property was found.
     Property *findPropertyByName( const std::string &name );
+    
+    /// @brief  Set a new value set.
+    /// @param  val     [in] The first value instance of the value set.
     void setValue( Value *val );
+
+    ///	@brief  Returns the first element of the assigned value set.
+    ///	@return The first property of the assigned value set.
     Value *getValue() const;
-    void setDataArrayList( DataArrayList  *dtArrayList );
+
+    /// @brief  Set a new DataArrayList.
+    /// @param  val     [in] The DataArrayList instance.
+    void setDataArrayList( DataArrayList *dtArrayList );
+
+    ///	@brief  Returns the DataArrayList.
+    ///	@return The DataArrayList.
     DataArrayList *getDataArrayList() const;
+
+    /// @brief  Set a new Reference set.
+    /// @param  val     [in] The first value instance of the Reference set.
     void setReferences( Reference  *refs );
+
+    ///	@brief  Returns the first element of the assigned Reference set.
+    ///	@return The first property of the assigned Reference set.
     Reference *getReferences() const;
+
+    ///	@brief  The creation method.
+    /// @param  type    [in] The DDLNode type.
+    ///	@param  name    [in] The name for the new DDLNode instance.
+    /// @param  parent  [in] The parent node instance or ddl_nullptr if no parent node is there.
+    /// @return The new created node instance.
     static DDLNode *create( const std::string &type, const std::string &name, DDLNode *parent = ddl_nullptr );
 
 private:
@@ -88,5 +158,3 @@ private:
 };
 
 END_ODDLPARSER_NS
-
-#endif // OPENDDLPARSER_DDLNODE_H_INC

contrib/openddlparser/include/openddlparser/OpenDDLCommon.h

@@ -21,14 +21,15 @@ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 -----------------------------------------------------------------------------------------------*/
 #pragma once
-#ifndef OPENDDLPARSER_OPENDDLPARSERCOMMON_H_INC
-#define OPENDDLPARSER_OPENDDLPARSERCOMMON_H_INC
 
 #include <cstddef>
 #include <vector>
 #include <string>
 
 #include <string.h>
+#ifndef _WIN32
+#  include <inttypes.h>
+#endif 
 
 #ifdef _MSC_VER
 #   define TAG_DLL_EXPORT __declspec(dllexport)
@@ -43,15 +44,19 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #   define DLL_ODDLPARSER_EXPORT
 #endif // _WIN32
 
+// Namespace declarations, override this to avoid any conflicts
 #define BEGIN_ODDLPARSER_NS namespace ODDLParser {
 #define END_ODDLPARSER_NS   } // namespace ODDLParser
 #define USE_ODDLPARSER_NS   using namespace ODDLParser;
 
 BEGIN_ODDLPARSER_NS
 
+// We will use C++11 optional
 #ifndef OPENDDL_NO_USE_CPP11
+    // All C++11 constructs
 #   define ddl_nullptr nullptr
 #else
+    // Fallback for older compilers
 #   define ddl_nullptr NULL
 #endif // OPENDDL_NO_USE_CPP11
 
@@ -64,20 +69,31 @@ struct Reference;
 struct Property;
 struct DataArrayList;
 
-typedef char           int8;
+#ifdef _WIN32
-typedef short          int16;
+typedef signed __int64    int64_impl;
-typedef int            int32;
+typedef unsigned __int64  uint64_impl;
-typedef long           int64;
+#else
-typedef unsigned char  uint8;
+typedef int64_t           int64_impl;
-typedef unsigned short uint16;
+typedef uint64_t          uint64_impl;
-typedef unsigned int   uint32;
+#endif
-typedef unsigned long  uint64;
 
+// OpenDDL-specific data typedefs
+typedef signed char       int8;    ///< Signed integer, 1 byte
+typedef signed short      int16;   ///< Signed integer, 2 byte
+typedef signed int        int32;   ///< Signed integer, 4 byte
+typedef int64_impl        int64;   ///< Signed integer, 8 byte
+typedef unsigned char     uint8;   ///< Unsigned integer, 1 byte
+typedef unsigned short    uint16;  ///< Unsigned integer, 2 byte
+typedef unsigned int      uint32;  ///< Unsigned integer, 4 byte
+typedef uint64_impl       uint64;  ///< Unsigned integer, 8 byte
+
+///	@brief  Description of the type of a name.
 enum NameType {
-    GlobalName,
+    GlobalName, ///< Name is global.
-    LocalName
+    LocalName   ///< Name is local.
 };
 
+///	@brief  Stores a text
 struct Text {
     size_t m_capacity;
     size_t m_len;
@@ -117,8 +133,8 @@ struct Text {
             return false;
         }
         const int res( strncmp( m_buffer, name.c_str(), name.size() ) );
-        return ( 0 == res );
         
+        return ( 0 == res );
     }
 
     bool operator == ( const Text &rhs ) const {
@@ -126,7 +142,8 @@ struct Text {
             return false;
         }
 
-        const int res ( strncmp( m_buffer, rhs.m_buffer, m_len ) );
+        const int res( strncmp( m_buffer, rhs.m_buffer, m_len ) );
+        
         return ( 0 == res );
     }
 
@@ -135,6 +152,7 @@ private:
     Text &operator = ( const Text & );
 };
 
+///	@brief  Stores an OpenDDL-specific identifier type.
 struct Identifier {
     Text m_text;
 
@@ -157,6 +175,7 @@ private:
     Identifier &operator = ( const Identifier & );
 };
 
+///	@brief  Stores an OpenDDL-specific name
 struct Name {
     NameType    m_type;
     Identifier *m_id;
@@ -172,6 +191,7 @@ private:
     Name &operator = ( const Name& );
 };
 
+///	@brief  Stores a bundle of references.
 struct Reference {
     size_t   m_numRefs;
     Name   **m_referencedName;
@@ -192,11 +212,20 @@ struct Reference {
         }
     }
 
+    ~Reference() {
+        for( size_t i = 0; i < m_numRefs; i++ ) {
+            delete m_referencedName[ i ];
+        }
+        m_numRefs = 0;
+        m_referencedName = ddl_nullptr;
+    }
+
 private:
     Reference( const Reference & );
     Reference &operator = ( const Reference & );
 };
 
+///	@brief  Stores a property list.
 struct Property {
     Identifier *m_key;
     Value *m_value;
@@ -204,18 +233,26 @@ struct Property {
     Property *m_next;
 
     Property( Identifier *id )
-        : m_key( id )
+    : m_key( id )
-        , m_value( ddl_nullptr )
+    , m_value( ddl_nullptr )
-        , m_ref( ddl_nullptr )
+    , m_ref( ddl_nullptr )
-        , m_next( ddl_nullptr ) {
+    , m_next( ddl_nullptr ) {
         // empty
     }
 
+    ~Property() {
+        m_key = ddl_nullptr;
+        m_value = ddl_nullptr;
+        m_ref = ddl_nullptr;;
+        m_next = ddl_nullptr;;
+    }
+
 private:
     Property( const Property & );
     Property &operator = ( const Property & );
 };
 
+///	@brief  Stores a data array list.
 struct DataArrayList {
     size_t m_numItems;
     Value *m_dataList;
@@ -231,9 +268,9 @@ struct DataArrayList {
 private:
     DataArrayList( const DataArrayList & ); 
     DataArrayList &operator = ( const DataArrayList & );
-
 };
 
+///	@brief  Stores the context of a parsed OpenDDL declaration.
 struct Context {
     DDLNode *m_root;
 
@@ -242,12 +279,13 @@ struct Context {
         // empty
     }
 
+    ~Context() {
+        m_root = ddl_nullptr;
+    }
+
 private:
     Context( const Context & );
     Context &operator = ( const Context & );
 };
 
 END_ODDLPARSER_NS
-
-#endif // OPENDDLPARSER_OPENDDLPARSERCOMMON_H_INC
-

contrib/openddlparser/include/openddlparser/OpenDDLParser.h

@@ -21,8 +21,6 @@ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 -----------------------------------------------------------------------------------------------*/
 #pragma once
-#ifndef OPENDDLPARSER_OPENDDLPARSER_H_INC
-#define OPENDDLPARSER_OPENDDLPARSER_H_INC
 
 #include <openddlparser/OpenDDLCommon.h>
 #include <openddlparser/DDLNode.h>
@@ -127,5 +125,3 @@ private:
 };
 
 END_ODDLPARSER_NS
-
-#endif // OPENDDLPARSER_OPENDDLPARSER_H_INC

contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h

@@ -21,8 +21,6 @@ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 -----------------------------------------------------------------------------------------------*/
 #pragma once
-#ifndef OPENDDLPARSER_OPENDDLPARSERUTILS_H_INC
-#define OPENDDLPARSER_OPENDDLPARSERUTILS_H_INC
 
 #include <openddlparser/OpenDDLCommon.h>
 
@@ -124,7 +122,6 @@ bool isInteger( T *in, T *end ) {
 
     bool result( false );
     while( isNotEndOfToken( in, end ) ) {
-        //while( '}' != *in && ',' != *in && !isSpace( *in ) && in != end ) {
         result = isNumeric( *in );
         if( !result ) {
             break;
@@ -147,8 +144,6 @@ bool isFloat( T *in, T *end ) {
     // check for <1>.0f
     bool result( false );
     while( isNotEndOfToken( in, end ) ) {
-
-//    while( !isSpace( *in ) && in != end ) {
         if( *in == '.' ) {
             result = true;
             break;
@@ -169,8 +164,6 @@ bool isFloat( T *in, T *end ) {
 
     // check for 1.<0>f
     while( isNotEndOfToken( in, end ) ) {
-
-//    while( !isSpace( *in ) && in != end && *in != ',' && *in != '}' ) {
         result = isNumeric( *in );
         if( !result ) {
             return false;
@@ -257,5 +250,3 @@ int hex2Decimal( char in ) {
 }
 
 END_ODDLPARSER_NS
-
-#endif // OPENDDLPARSER_OPENDDLPARSERUTILS_H_INC

contrib/openddlparser/include/openddlparser/Value.h

@@ -21,8 +21,6 @@ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 -----------------------------------------------------------------------------------------------*/
 #pragma once
-#ifndef OPENDDLPARSER_VALUE_H_INC
-#define OPENDDLPARSER_VALUE_H_INC
 
 #include <openddlparser/OpenDDLCommon.h>
 
@@ -30,6 +28,8 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 BEGIN_ODDLPARSER_NS
 
+struct ValueAllocator;
+
 ///------------------------------------------------------------------------------------------------
 ///	@brief  This class implements a value.
 ///
@@ -38,7 +38,49 @@ BEGIN_ODDLPARSER_NS
 /// Values can be single items or lists of items. They are implemented as linked lists.
 ///------------------------------------------------------------------------------------------------
 class DLL_ODDLPARSER_EXPORT Value {
+    friend struct ValueAllocator;
+
 public:
+    ///	@brief  This class implements an iterator through a Value list.
+    ///	
+    /// When getting a new value you need to know how to iterate through it. The Value::Iterator 
+    /// will help you here:
+    ///	@code
+    /// Value *val = node->getValue();
+    /// Value::Iterator it( val );
+    /// while( it.hasNext() ) {
+    ///     Value v( it.getNext );
+    /// }
+    /// @endcode
+    class DLL_ODDLPARSER_EXPORT Iterator {
+    public:
+        ///	@brief  The default class constructor.
+        Iterator();
+
+        ///	@brief  The class constructor with the start value.
+        /// @param  start   [in] The first value for iteration,
+        Iterator( Value *start );
+
+        ///	@brief  The class destructor.
+        ~Iterator();
+
+        ///	@brief  Will return true, if another value is in the list.
+        /// @return true if another value is there.
+        bool hasNext() const;
+
+        ///	@brief  Returns the next item and moves the iterator to it.
+        ///	@return The next value, is ddl_nullptr in case of being the last item.
+        Value *getNext();
+
+    private:
+        Value *m_start;
+        Value *m_current;
+
+    private:
+        Iterator( const Iterator & );
+        Iterator &operator = ( const Iterator & );
+    };
+
     ///	@brief  This enum describes the data type stored in the value.
     enum ValueType {
         ddl_none = -1,          ///< Nothing specified
@@ -59,7 +101,7 @@ public:
         ddl_types_max
     };
 
-    Value();
+    Value( ValueType type );
     ~Value();
     void setBool( bool value );
     bool getBool();
@@ -101,5 +143,3 @@ struct DLL_ODDLPARSER_EXPORT ValueAllocator {
 };
 
 END_ODDLPARSER_NS
-
-#endif // OPENDDLPARSER_VALUE_H_INC

include/assimp/Exporter.hpp

@@ -109,7 +109,14 @@ public:
 			mEnforcePP = pEnforcePP;
 		}
 
-		ExportFormatEntry() : mExportFunction(), mEnforcePP() {}
+		ExportFormatEntry() :
+		    mExportFunction()
+		  , mEnforcePP()
+		{
+			mDescription.id = NULL;
+			mDescription.description = NULL;
+			mDescription.fileExtension = NULL;
+		}
 	};
 
 

include/assimp/cimport.h

@@ -45,6 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_ASSIMP_H_INC
 #define AI_ASSIMP_H_INC
 #include "types.h"
+#include <assimp/importerdesc.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -539,7 +540,20 @@ ASSIMP_API void aiIdentityMatrix3(
 ASSIMP_API void aiIdentityMatrix4(
 	C_STRUCT aiMatrix4x4* mat);
 
+// --------------------------------------------------------------------------------
+/** Returns the number of import file formats available in the current Assimp build.
+ * Use aiGetImportFormatDescription() to retrieve infos of a specific import format.
+ */
+ASSIMP_API size_t aiGetImportFormatCount(void);
 
+// --------------------------------------------------------------------------------
+/** Returns a description of the nth import file format. Use #aiGetImportFormatCount()
+ * to learn how many import formats are supported. 
+ * @param pIndex Index of the import format to retrieve information for. Valid range is
+ *    0 to #aiGetImportFormatCount()
+ * @return A description of that specific import format. NULL if pIndex is out of range.
+ */
+ASSIMP_API const C_STRUCT aiImporterDesc* aiGetImportFormatDescription( size_t pIndex);
 #ifdef __cplusplus
 }
 #endif

include/assimp/defs.h

@@ -209,7 +209,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #if (defined(__BORLANDC__) || defined (__BCPLUSPLUS__))
 #error Currently, Borland is unsupported. Feel free to port Assimp.
 
-// "W8059 Packgröße der Struktur geändert"
+// "W8059 Packgr<EFBFBD><EFBFBD>e der Struktur ge<67>ndert"
 
 #endif
 	//////////////////////////////////////////////////////////////////////////
@@ -257,8 +257,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_MATH_HALF_PI_F	(AI_MATH_PI_F * 0.5f)
 
 /* Tiny macro to convert from radians to degrees and back */
-#define AI_DEG_TO_RAD(x) (x*0.0174532925f)
+#define AI_DEG_TO_RAD(x) ((x)*0.0174532925f)
-#define AI_RAD_TO_DEG(x) (x*57.2957795f)
+#define AI_RAD_TO_DEG(x) ((x)*57.2957795f)
 
 /* Support for big-endian builds */
 #if defined(__BYTE_ORDER__)

include/assimp/importerdesc.h

@@ -138,6 +138,6 @@ Will return a NULL-pointer if no assigned importer desc. was found for the given
     \param  extension   [in] The extension to look for
     \return A pointer showing to the ImporterDesc, \see aiImporterDesc.
 */
-ASSIMP_API C_STRUCT const aiImporterDesc* aiGetImporterDesc( const char *extension );
+ASSIMP_API const C_STRUCT aiImporterDesc* aiGetImporterDesc( const char *extension );
 
 #endif 

port/Assimp.NET/Assimp.NET.sln

@@ -1,275 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 10.00
-# Visual Studio 2008
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Assimp_NET", "Assimp.NET\Assimp.NET.vcproj", "{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}"
-	ProjectSection(ProjectDependencies) = postProject
-		{5691E159-2D9B-407F-971F-EA5C592DC524} = {5691E159-2D9B-407F-971F-EA5C592DC524}
-	EndProjectSection
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Assimp.NET_CS", "Assimp.NET_CS\Assimp.NET_CS.csproj", "{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}"
-	ProjectSection(ProjectDependencies) = postProject
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E} = {A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}
-	EndProjectSection
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Assimp.NET_DEMO", "Assimp.NET_DEMO\Assimp.NET_DEMO.csproj", "{B2813591-1491-4C99-B6E2-67B484411AFC}"
-	ProjectSection(ProjectDependencies) = postProject
-		{5691E159-2D9B-407F-971F-EA5C592DC524} = {5691E159-2D9B-407F-971F-EA5C592DC524}
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "assimp", "..\..\workspaces\vc9\assimp.vcproj", "{5691E159-2D9B-407F-971F-EA5C592DC524}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Debug|Mixed Platforms = Debug|Mixed Platforms
-		Debug|Win32 = Debug|Win32
-		Debug|x86 = Debug|x86
-		debug-dll|Any CPU = debug-dll|Any CPU
-		debug-dll|Mixed Platforms = debug-dll|Mixed Platforms
-		debug-dll|Win32 = debug-dll|Win32
-		debug-dll|x86 = debug-dll|x86
-		debug-noboost-st|Any CPU = debug-noboost-st|Any CPU
-		debug-noboost-st|Mixed Platforms = debug-noboost-st|Mixed Platforms
-		debug-noboost-st|Win32 = debug-noboost-st|Win32
-		debug-noboost-st|x86 = debug-noboost-st|x86
-		debug-st|Any CPU = debug-st|Any CPU
-		debug-st|Mixed Platforms = debug-st|Mixed Platforms
-		debug-st|Win32 = debug-st|Win32
-		debug-st|x86 = debug-st|x86
-		Release|Any CPU = Release|Any CPU
-		Release|Mixed Platforms = Release|Mixed Platforms
-		Release|Win32 = Release|Win32
-		Release|x86 = Release|x86
-		release-dll|Any CPU = release-dll|Any CPU
-		release-dll|Mixed Platforms = release-dll|Mixed Platforms
-		release-dll|Win32 = release-dll|Win32
-		release-dll|x86 = release-dll|x86
-		release-noboost-st|Any CPU = release-noboost-st|Any CPU
-		release-noboost-st|Mixed Platforms = release-noboost-st|Mixed Platforms
-		release-noboost-st|Win32 = release-noboost-st|Win32
-		release-noboost-st|x86 = release-noboost-st|x86
-		release-st|Any CPU = release-st|Any CPU
-		release-st|Mixed Platforms = release-st|Mixed Platforms
-		release-st|Win32 = release-st|Win32
-		release-st|x86 = release-st|x86
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.Debug|Any CPU.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.Debug|Mixed Platforms.Build.0 = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.Debug|Win32.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.Debug|Win32.Build.0 = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.Debug|x86.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-dll|Any CPU.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-dll|Mixed Platforms.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-dll|Mixed Platforms.Build.0 = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-dll|Win32.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-dll|Win32.Build.0 = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-dll|x86.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-noboost-st|Any CPU.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-noboost-st|Mixed Platforms.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-noboost-st|Mixed Platforms.Build.0 = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-noboost-st|Win32.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-noboost-st|Win32.Build.0 = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-noboost-st|x86.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-st|Any CPU.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-st|Mixed Platforms.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-st|Mixed Platforms.Build.0 = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-st|Win32.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-st|Win32.Build.0 = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.debug-st|x86.ActiveCfg = Debug|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.Release|Any CPU.ActiveCfg = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.Release|Mixed Platforms.ActiveCfg = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.Release|Mixed Platforms.Build.0 = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.Release|Win32.ActiveCfg = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.Release|Win32.Build.0 = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.Release|x86.ActiveCfg = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.Release|x86.Build.0 = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-dll|Any CPU.ActiveCfg = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-dll|Mixed Platforms.ActiveCfg = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-dll|Mixed Platforms.Build.0 = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-dll|Win32.ActiveCfg = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-dll|Win32.Build.0 = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-dll|x86.ActiveCfg = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-noboost-st|Any CPU.ActiveCfg = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-noboost-st|Mixed Platforms.ActiveCfg = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-noboost-st|Mixed Platforms.Build.0 = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-noboost-st|Win32.ActiveCfg = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-noboost-st|Win32.Build.0 = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-noboost-st|x86.ActiveCfg = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-st|Any CPU.ActiveCfg = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-st|Mixed Platforms.ActiveCfg = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-st|Mixed Platforms.Build.0 = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-st|Win32.ActiveCfg = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-st|Win32.Build.0 = Release|Win32
-		{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}.release-st|x86.ActiveCfg = Release|Win32
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Debug|Win32.ActiveCfg = Debug|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Debug|Win32.Build.0 = Debug|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Debug|x86.ActiveCfg = Debug|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Debug|x86.Build.0 = Debug|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-dll|Any CPU.ActiveCfg = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-dll|Any CPU.Build.0 = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-dll|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-dll|Mixed Platforms.Build.0 = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-dll|Win32.ActiveCfg = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-dll|x86.ActiveCfg = Debug|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-dll|x86.Build.0 = Debug|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-noboost-st|Any CPU.ActiveCfg = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-noboost-st|Any CPU.Build.0 = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-noboost-st|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-noboost-st|Mixed Platforms.Build.0 = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-noboost-st|Win32.ActiveCfg = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-noboost-st|x86.ActiveCfg = Debug|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-noboost-st|x86.Build.0 = Debug|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-st|Any CPU.ActiveCfg = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-st|Any CPU.Build.0 = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-st|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-st|Mixed Platforms.Build.0 = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-st|Win32.ActiveCfg = Debug|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-st|x86.ActiveCfg = Debug|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.debug-st|x86.Build.0 = Debug|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Release|Any CPU.Build.0 = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Release|Win32.ActiveCfg = Release|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Release|Win32.Build.0 = Release|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Release|x86.ActiveCfg = Release|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Release|x86.Build.0 = Release|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-dll|Any CPU.ActiveCfg = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-dll|Any CPU.Build.0 = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-dll|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-dll|Mixed Platforms.Build.0 = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-dll|Win32.ActiveCfg = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-dll|x86.ActiveCfg = Release|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-dll|x86.Build.0 = Release|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-noboost-st|Any CPU.ActiveCfg = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-noboost-st|Any CPU.Build.0 = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-noboost-st|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-noboost-st|Mixed Platforms.Build.0 = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-noboost-st|Win32.ActiveCfg = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-noboost-st|x86.ActiveCfg = Release|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-noboost-st|x86.Build.0 = Release|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-st|Any CPU.ActiveCfg = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-st|Any CPU.Build.0 = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-st|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-st|Mixed Platforms.Build.0 = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-st|Win32.ActiveCfg = Release|Any CPU
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-st|x86.ActiveCfg = Release|x86
-		{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.release-st|x86.Build.0 = Release|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Debug|Win32.ActiveCfg = Debug|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Debug|Win32.Build.0 = Debug|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Debug|x86.ActiveCfg = Debug|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Debug|x86.Build.0 = Debug|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-dll|Any CPU.ActiveCfg = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-dll|Any CPU.Build.0 = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-dll|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-dll|Mixed Platforms.Build.0 = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-dll|Win32.ActiveCfg = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-dll|x86.ActiveCfg = Debug|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-dll|x86.Build.0 = Debug|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-noboost-st|Any CPU.ActiveCfg = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-noboost-st|Any CPU.Build.0 = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-noboost-st|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-noboost-st|Mixed Platforms.Build.0 = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-noboost-st|Win32.ActiveCfg = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-noboost-st|x86.ActiveCfg = Debug|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-noboost-st|x86.Build.0 = Debug|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-st|Any CPU.ActiveCfg = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-st|Any CPU.Build.0 = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-st|Mixed Platforms.ActiveCfg = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-st|Mixed Platforms.Build.0 = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-st|Win32.ActiveCfg = Debug|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-st|x86.ActiveCfg = Debug|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.debug-st|x86.Build.0 = Debug|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Release|Any CPU.Build.0 = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Release|Mixed Platforms.Build.0 = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Release|Win32.ActiveCfg = Release|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Release|Win32.Build.0 = Release|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Release|x86.ActiveCfg = Release|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.Release|x86.Build.0 = Release|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-dll|Any CPU.ActiveCfg = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-dll|Any CPU.Build.0 = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-dll|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-dll|Mixed Platforms.Build.0 = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-dll|Win32.ActiveCfg = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-dll|x86.ActiveCfg = Release|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-dll|x86.Build.0 = Release|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-noboost-st|Any CPU.ActiveCfg = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-noboost-st|Any CPU.Build.0 = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-noboost-st|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-noboost-st|Mixed Platforms.Build.0 = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-noboost-st|Win32.ActiveCfg = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-noboost-st|x86.ActiveCfg = Release|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-noboost-st|x86.Build.0 = Release|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-st|Any CPU.ActiveCfg = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-st|Any CPU.Build.0 = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-st|Mixed Platforms.ActiveCfg = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-st|Mixed Platforms.Build.0 = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-st|Win32.ActiveCfg = Release|Any CPU
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-st|x86.ActiveCfg = Release|x86
-		{B2813591-1491-4C99-B6E2-67B484411AFC}.release-st|x86.Build.0 = Release|x86
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.Debug|Any CPU.ActiveCfg = debug|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.Debug|Mixed Platforms.ActiveCfg = debug|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.Debug|Mixed Platforms.Build.0 = debug|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.Debug|Win32.ActiveCfg = debug|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.Debug|Win32.Build.0 = debug|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.Debug|x86.ActiveCfg = debug|x64
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-dll|Any CPU.ActiveCfg = debug-dll|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-dll|Mixed Platforms.ActiveCfg = debug-dll|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-dll|Mixed Platforms.Build.0 = debug-dll|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-dll|Win32.ActiveCfg = debug-dll|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-dll|Win32.Build.0 = debug-dll|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-dll|x86.ActiveCfg = debug-dll|x64
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-noboost-st|Any CPU.ActiveCfg = debug-noboost-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-noboost-st|Mixed Platforms.ActiveCfg = debug-noboost-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-noboost-st|Mixed Platforms.Build.0 = debug-noboost-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-noboost-st|Win32.ActiveCfg = debug-noboost-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-noboost-st|Win32.Build.0 = debug-noboost-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-noboost-st|x86.ActiveCfg = debug-noboost-st|x64
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-st|Any CPU.ActiveCfg = debug-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-st|Mixed Platforms.ActiveCfg = debug-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-st|Mixed Platforms.Build.0 = debug-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-st|Win32.ActiveCfg = debug-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-st|Win32.Build.0 = debug-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.debug-st|x86.ActiveCfg = debug-st|x64
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.Release|Any CPU.ActiveCfg = release|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.Release|Mixed Platforms.ActiveCfg = release|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.Release|Mixed Platforms.Build.0 = release|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.Release|Win32.ActiveCfg = release|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.Release|Win32.Build.0 = release|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.Release|x86.ActiveCfg = release|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.Release|x86.Build.0 = release|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-dll|Any CPU.ActiveCfg = release-dll|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-dll|Mixed Platforms.ActiveCfg = release-dll|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-dll|Mixed Platforms.Build.0 = release-dll|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-dll|Win32.ActiveCfg = release-dll|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-dll|Win32.Build.0 = release-dll|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-dll|x86.ActiveCfg = release-dll|x64
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-noboost-st|Any CPU.ActiveCfg = release-noboost-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-noboost-st|Mixed Platforms.ActiveCfg = release-noboost-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-noboost-st|Mixed Platforms.Build.0 = release-noboost-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-noboost-st|Win32.ActiveCfg = release-noboost-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-noboost-st|Win32.Build.0 = release-noboost-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-noboost-st|x86.ActiveCfg = release-noboost-st|x64
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-st|Any CPU.ActiveCfg = release-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-st|Mixed Platforms.ActiveCfg = release-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-st|Mixed Platforms.Build.0 = release-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-st|Win32.ActiveCfg = release-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-st|Win32.Build.0 = release-st|Win32
-		{5691E159-2D9B-407F-971F-EA5C592DC524}.release-st|x86.ActiveCfg = release-st|x64
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal

port/Assimp.NET/Assimp.NET/Assimp.NET.vcproj

@@ -1,237 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="9.00"
-	Name="Assimp_NET"
-	ProjectGUID="{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}"
-	RootNamespace="AssimpNET"
-	Keyword="ManagedCProj"
-	TargetFrameworkVersion="196613"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="..\..\..\bin\$(ProjectName)_$(ConfigurationName)_$(PlatformName)"
-			IntermediateDirectory="..\..\..\bin\$(ProjectName)_$(ConfigurationName)_$(PlatformName)"
-			ConfigurationType="2"
-			CharacterSet="1"
-			ManagedExtensions="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-				CommandLine=""
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-				CommandLine=""
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				PreprocessorDefinitions="WIN32;_DEBUG"
-				RuntimeLibrary="3"
-				EnableFunctionLevelLinking="true"
-				UsePrecompiledHeader="0"
-				WarningLevel="4"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				OutputFile="$(OutDir)\Assimp.dll"
-				LinkIncremental="2"
-				AdditionalLibraryDirectories=""
-				EnableUAC="false"
-				AddModuleNamesToAssembly=""
-				GenerateDebugInformation="true"
-				AssemblyDebug="1"
-				SubSystem="2"
-				TargetMachine="1"
-				CLRThreadAttribute="1"
-				CLRUnmanagedCodeCheck="false"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-				CommandLine=""
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="..\..\..\bin\$(ProjectName)_$(ConfigurationName)_$(PlatformName)"
-			IntermediateDirectory="..\..\..\bin\$(ProjectName)_$(ConfigurationName)_$(PlatformName)"
-			ConfigurationType="2"
-			CharacterSet="1"
-			ManagedExtensions="1"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				PreprocessorDefinitions="WIN32;NDEBUG"
-				RuntimeLibrary="2"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				AdditionalDependencies="$(NoInherit)"
-				OutputFile="$(OutDir)\Assimp.dll"
-				LinkIncremental="1"
-				GenerateDebugInformation="true"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-		<AssemblyReference
-			RelativePath="System.dll"
-			AssemblyName="System, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL"
-			MinFrameworkVersion="131072"
-		/>
-		<AssemblyReference
-			RelativePath="System.Data.dll"
-			AssemblyName="System.Data, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=x86"
-			MinFrameworkVersion="131072"
-		/>
-		<AssemblyReference
-			RelativePath="System.XML.dll"
-			AssemblyName="System.Xml, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL"
-			MinFrameworkVersion="131072"
-		/>
-	</References>
-	<Files>
-		<Filter
-			Name="Quelldateien"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath=".\AssimpSwigPort_wrap.cxx"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Headerdateien"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-		</Filter>
-		<Filter
-			Name="Ressourcendateien"
-			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
-			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
-			>
-		</Filter>
-		<File
-			RelativePath=".\AssimpSwigPort.i"
-			>
-			<FileConfiguration
-				Name="Debug|Win32"
-				>
-				<Tool
-					Name="VCCustomBuildTool"
-					CommandLine="echo Invoking SWIG...&#x0D;&#x0A;echo on&#x0D;&#x0A;swig.exe -c++ -csharp -cpperraswarn -outdir &quot;$(SolutionDir)\Assimp.NET_CS&quot; &quot;$(InputPath)&quot;&#x0D;&#x0A;@echo off&#x0D;&#x0A;"
-					Outputs="$(InputName)_wrap.cxx"
-				/>
-			</FileConfiguration>
-			<FileConfiguration
-				Name="Release|Win32"
-				>
-				<Tool
-					Name="VCCustomBuildTool"
-					CommandLine="echo Invoking SWIG...&#x0D;&#x0A;echo on&#x0D;&#x0A;swig.exe -c++ -csharp -cpperraswarn -outdir &quot;$(SolutionDir)\Assimp.NET_CS&quot; &quot;$(InputPath)&quot;&#x0D;&#x0A;@echo off&#x0D;&#x0A;"
-					Outputs="$(InputName)_wrap.cxx"
-				/>
-			</FileConfiguration>
-		</File>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>

port/Assimp.NET/Assimp.NET/AssimpSwigPort.i

@@ -1,567 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (ASSIMP)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2010, ASSIMP Development Team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms, 
-with or without modification, are permitted provided that the following 
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the ASSIMP team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the ASSIMP Development Team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-%module Assimp
-
-%include "carrays.i"
-%include "typemaps.i"
-%{
-#include "..\..\..\include\assimp\defs.h"
-#include "..\..\..\include\assimp\config.h"
-#include "..\..\..\include\assimp\types.h"
-#include "..\..\..\include\assimp\version.h"
-#include "..\..\..\include\assimp\postprocess.h"
-#include "..\..\..\include\assimp\vector2.h"
-#include "..\..\..\include\assimp\vector3.h"
-#include "..\..\..\include\assimp\color4.h"
-#include "..\..\..\include\assimp\matrix3x3.h"
-#include "..\..\..\include\assimp\matrix4x4.h"
-#include "..\..\..\include\assimp\camera.h"
-#include "..\..\..\include\assimp\light.h"
-#include "..\..\..\include\assimp\anim.h"
-#include "..\..\..\include\assimp\mesh.h"
-#include "..\..\..\include\assimp\cfileio.h"
-#include "..\..\..\include\assimp\material.h"
-#include "..\..\..\include\assimp\quaternion.h"
-#include "..\..\..\include\assimp\scene.h"
-#include "..\..\..\include\assimp\texture.h"
-#include "..\..\..\include\assimp\Importer.hpp"
-#include "..\..\..\include\assimp\IOSystem.hpp"
-#include "..\..\..\include\assimp\IOStream.hpp"
-#include "..\..\..\include\assimp\Logger.hpp"
-#include "..\..\..\include\assimp\LogStream.hpp"
-#include "..\..\..\include\assimp\NullLogger.hpp"
-#include "..\..\..\include\assimp\ProgressHandler.hpp"
-%}
-
-#define C_STRUCT
-#define C_ENUM
-#define ASSIMP_API
-#define PACK_STRUCT
-#define AI_FORCE_INLINE
-
-%rename(__add__) operator+;
-%rename(__addnset__) operator+=;
-%rename(__sub__) operator-;
-%rename(__subnset__) operator-=;
-%rename(__mul__) operator*;
-%rename(__mulnset__) operator*=;
-%rename(__div__) operator/;
-%rename(__divnset__) operator/=;
-%rename(__equal__) operator==;
-%rename(__nequal__) operator!=;
-%rename(__idx__) operator[];
-%rename(__set__) operator=;
-%rename(__greater__) operator>;
-%rename(__smaller__) operator<;
-
-
-%rename(opNew) operator new;
-%rename(opNewArray) operator new[];
-
-%rename(opDelete) operator delete;
-%rename(opDeleteArray) operator delete[];
-
-
-%include "std_string.i"
-%include "std_vector.i"
-
-
-// PACK_STRUCT is a no-op for SWIG – it does not matter for the generated
-// bindings how the underlying C++ code manages its memory.
-#define PACK_STRUCT
-
-
-// Helper macros for wrapping the pointer-and-length arrays used in the
-// Assimp API.
-
-%define ASSIMP_ARRAY(CLASS, TYPE, NAME, LENGTH)
-%csmethodmodifiers Get##NAME() "private";
-%newobject CLASS::Get##NAME;
-%extend CLASS {
-  std::vector<TYPE > *Get##NAME() {
-    std::vector<TYPE > *result = new std::vector<TYPE >;
-    result->reserve(LENGTH);
-
-    for (unsigned int i = 0; i < LENGTH; ++i) {
-      result->push_back($self->NAME[i]);
-    }
-
-    return result;
-  }
-}
-%ignore CLASS::NAME;
-%enddef
-
-%define ASSIMP_POINTER_ARRAY(CLASS, TYPE, NAME, LENGTH)
-%csmethodmodifiers Get##NAME() "private";
-%newobject CLASS::Get##NAME;
-%extend CLASS {
-  std::vector<TYPE *> *Get##NAME() {
-    std::vector<TYPE *> *result = new std::vector<TYPE *>;
-    result->reserve(LENGTH);
-	 	
-    TYPE *currentValue = (TYPE *)$self->NAME;
-    TYPE *valueLimit = (TYPE *)$self->NAME + LENGTH;
-    while (currentValue < valueLimit) {
-      result->push_back(currentValue);
-      ++currentValue;
-    }
- 	
-    return result;
-  }
-}
-%ignore CLASS::NAME;
-%enddef 
-
-%define ASSIMP_POINTER_POINTER(CLASS, TYPE, NAME, LENGTH)
-%csmethodmodifiers Get##NAME() "private";
-%newobject CLASS::Get##NAME;
-%extend CLASS {
-  std::vector<TYPE *> *Get##NAME() {
-    std::vector<TYPE *> *result = new std::vector<TYPE *>;
-    result->reserve(LENGTH);
-
-    TYPE **currentValue = $self->NAME;
-    TYPE **valueLimit = $self->NAME + LENGTH;
-    while (currentValue < valueLimit) {
-      result->push_back(*currentValue);
-      ++currentValue;
-    }
-
-    return result;
-  }
-}
-%ignore CLASS::NAME;
-%enddef
-
-%define ASSIMP_POINTER_ARRAY_ARRAY(CLASS, TYPE, NAME, OUTER_LENGTH, INNER_LENGTH)
-%csmethodmodifiers Get##NAME() "private";
-%newobject CLASS::Get##NAME;
-%extend CLASS {
-  std::vector< std::vector<TYPE*> > *Get##NAME() {
-    std::vector< std::vector<TYPE*> > *result = new std::vector< std::vector<TYPE*> >;
-    result->reserve(OUTER_LENGTH);
-
-    for (unsigned int i = 0; i < OUTER_LENGTH; ++i) {
-      std::vector<TYPE *> currentElements;
-
-      if ($self->NAME[i] != 0) {
-        currentElements.reserve(INNER_LENGTH);
-
-        TYPE *currentValue = $self->NAME[i];
-        TYPE *valueLimit = $self->NAME[i] + INNER_LENGTH;
-        while (currentValue < valueLimit) {
-          currentElements.push_back(currentValue);
-          ++currentValue;
-        }
-      }
-
-      result->push_back(currentElements);
-    }
-
-    return result;
-  }
-}
-%ignore CLASS::NAME;
-%enddef
-
-%define ASSIMP_GETMATERIAL(XXX, KEY, TYPE, NAME)
-%csmethodmodifiers Get##NAME() "private";
-%newobject aiMaterial::Get##NAME;
-%extend aiMaterial {
-  bool Get##NAME(TYPE* INOUT) {
-         return aiGetMaterial##XXX($self, KEY, INOUT) == AI_SUCCESS;
-  }
-}
-%enddef
-
-
-/////// aiAnimation 
-ASSIMP_POINTER_POINTER(aiAnimation,aiNodeAnim,mChannels,$self->mNumChannels);
-ASSIMP_POINTER_POINTER(aiAnimation,aiMeshAnim,mMeshChannels,$self->mNumMeshChannels);
-%typemap(cscode) aiAnimation %{
-  public aiNodeAnimVector mChannels { get { return GetmChannels(); } }
-  public aiMeshAnimVector mMeshChannels { get { return GetmMeshChannels(); } }
-%}
-
-/////// aiAnimMesh 
-%ignore aiAnimMesh::mVertices;
-%ignore aiAnimMesh::mNormals;
-%ignore aiAnimMesh::mTangents;
-%ignore aiAnimMesh::mColors;
-%ignore aiAnimMesh::mTextureCoords;
-
-/////// aiBone 
-ASSIMP_POINTER_ARRAY(aiBone,aiVertexWeight,mWeights,$self->mNumWeights);
-
-/////// aiCamera 
-// OK
-
-/////// aiColor3D 
-// OK
-
-/////// aiColor4D 
-// OK
-
-/////// aiFace 
-ASSIMP_ARRAY(aiFace,unsigned int,mIndices,$self->mNumIndices);
-%typemap(cscode) aiFace %{
-  public UintVector mIndices { get { return GetmIndices(); } }
-%}
-
-/////// TODO: aiFile 
-%ignore aiFile;
-%ignore aiFile::FileSizeProc;
-%ignore aiFile::FlushProc;
-%ignore aiFile::ReadProc;
-%ignore aiFile::SeekProc;
-%ignore aiFile::TellProc;
-%ignore aiFile::WriteProc;
-
-/////// TODO: aiFileIO 
-%ignore aiFileIO;
-%ignore aiFileIO::CloseProc;
-%ignore aiFileIO::OpenPrc;
-
-/////// aiLight 
-// Done
-
-/////// aiLightSourceType 
-// Done
-
-/////// TODO: aiLogStream 
-%ignore aiLogStream;
-%ignore aiLogStream::callback;
-
-/////// aiMaterial 
-%ignore aiMaterial::Get;
-%ignore aiMaterial::GetTexture;
-%ignore aiMaterial::mNumAllocated;
-%ignore aiMaterial::mNumProperties;
-%ignore aiMaterial::mProperties;
-ASSIMP_GETMATERIAL(Color,   AI_MATKEY_COLOR_DIFFUSE,        aiColor4D,  Diffuse);
-ASSIMP_GETMATERIAL(Color,   AI_MATKEY_COLOR_SPECULAR,       aiColor4D,  Specular);
-ASSIMP_GETMATERIAL(Color,   AI_MATKEY_COLOR_AMBIENT,        aiColor4D,  Ambient);
-ASSIMP_GETMATERIAL(Color,   AI_MATKEY_COLOR_EMISSIVE,       aiColor4D,  Emissive);
-ASSIMP_GETMATERIAL(Float,   AI_MATKEY_OPACITY,              float,      Opacity);
-ASSIMP_GETMATERIAL(Float,   AI_MATKEY_SHININESS_STRENGTH,   float,      ShininessStrength);
-ASSIMP_GETMATERIAL(Integer, AI_MATKEY_SHADING_MODEL,        int,        ShadingModel);
-ASSIMP_GETMATERIAL(Integer, AI_MATKEY_TEXFLAGS_DIFFUSE(0),  int,        TexFlagsDiffuse0);
-ASSIMP_GETMATERIAL(Integer, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0),int,     MappingModeUDiffuse0);
-ASSIMP_GETMATERIAL(Integer, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0),int,     MappingModeVDiffuse0);
-ASSIMP_GETMATERIAL(String,  AI_MATKEY_TEXTURE_DIFFUSE(0),   aiString,   TextureDiffuse0);
-ASSIMP_GETMATERIAL(String,  AI_MATKEY_TEXTURE_SPECULAR(0),  aiString,   TextureSpecular0);
-ASSIMP_GETMATERIAL(String,  AI_MATKEY_TEXTURE_OPACITY(0),   aiString,   TextureOpacity0);
-ASSIMP_GETMATERIAL(String,  AI_MATKEY_TEXTURE_AMBIENT(0),   aiString,   TextureAmbient0);
-ASSIMP_GETMATERIAL(String,  AI_MATKEY_TEXTURE_EMISSIVE(0),  aiString,   TextureEmissive0);
-ASSIMP_GETMATERIAL(String,  AI_MATKEY_TEXTURE_SHININESS(0), aiString,   TextureShininess0);
-ASSIMP_GETMATERIAL(String,  AI_MATKEY_TEXTURE_LIGHTMAP(0),  aiString,   TextureLightmap0);
-ASSIMP_GETMATERIAL(String,  AI_MATKEY_TEXTURE_NORMALS(0),   aiString,   TextureNormals0);
-ASSIMP_GETMATERIAL(String,  AI_MATKEY_TEXTURE_HEIGHT(0),    aiString,   TextureHeight0);
-ASSIMP_GETMATERIAL(String,  AI_MATKEY_GLOBAL_BACKGROUND_IMAGE, aiString, GlobalBackgroundImage);
-ASSIMP_GETMATERIAL(Integer, AI_MATKEY_TWOSIDED,             int,   TwoSided);
-%typemap(cscode) aiMaterial %{
-    public aiColor4D Diffuse { get { var v = new aiColor4D(); return GetDiffuse(v)?v:DefaultDiffuse; } }
-    public aiColor4D Specular { get { var v = new aiColor4D(); return GetSpecular(v)?v:DefaultSpecular; } }
-    public aiColor4D Ambient { get { var v = new aiColor4D(); return GetAmbient(v)?v:DefaultAmbient; } }
-    public aiColor4D Emissive { get { var v = new aiColor4D(); return GetEmissive(v)?v:DefaultEmissive; } }
-    public float Opacity { get { float v = 0; return GetOpacity(ref v)?v:DefaultOpacity; } }
-    public float ShininessStrength { get { float v = 0; return GetShininessStrength(ref v)?v:DefaultShininessStrength; } }    
-    public aiShadingMode ShadingModel { get { int v = 0; return GetShadingModel(ref v)?((aiShadingMode)v):DefaultShadingModel; } }
-    public aiTextureFlags TexFlagsDiffuse0 { get { int v = 0; return GetTexFlagsDiffuse0(ref v)?((aiTextureFlags)v):DefaultTexFlagsDiffuse0; } }
-    public aiTextureMapMode MappingModeUDiffuse0 { get { int v = 0; return GetMappingModeUDiffuse0(ref v)?((aiTextureMapMode)v):DefaultMappingModeUDiffuse0; } }
-    public aiTextureMapMode MappingModeVDiffuse0 { get { int v = 0; return GetMappingModeVDiffuse0(ref v)?((aiTextureMapMode)v):DefaultMappingModeVDiffuse0; } }
-    public string TextureDiffuse0 { get { var v = new aiString(); return GetTextureDiffuse0(v)?v.ToString():DefaultTextureDiffuse; } }
-    public bool TwoSided { get { int v = 0; return GetTwoSided(ref v)?(v!=0):DefaultTwoSided; } }
-    
-    // These values are returned if the value material property isn't set
-    // Override these if you don't want to check for null
-    public static aiColor4D DefaultDiffuse = new aiColor4D(1.0f, 1.0f, 1.0f, 1.0f);
-    public static aiColor4D DefaultSpecular = new aiColor4D(1.0f, 1.0f, 1.0f, 1.0f);
-    public static aiColor4D DefaultAmbient = new aiColor4D(0.0f, 0.0f, 0.0f, 1.0f);
-    public static aiColor4D DefaultEmissive = new aiColor4D(0.0f, 0.0f, 0.0f, 1.0f);
-    public static float DefaultShininessStrength = 1.0f;
-    public static float DefaultOpacity = 1.0f;
-    public static aiShadingMode DefaultShadingModel = (aiShadingMode)0;
-    public static aiTextureFlags DefaultTexFlagsDiffuse0 = (aiTextureFlags)0;
-    public static aiTextureMapMode DefaultMappingModeUDiffuse0 = aiTextureMapMode.aiTextureMapMode_Wrap;
-    public static aiTextureMapMode DefaultMappingModeVDiffuse0 = aiTextureMapMode.aiTextureMapMode_Wrap;
-    public static string DefaultTextureDiffuse = null;
-    public static bool DefaultTwoSided = false;
-%}
-
-/////// aiMatrix3x3 
-%ignore aiMatrix3x3::operator!=;
-%ignore aiMatrix3x3::operator*;
-%ignore aiMatrix3x3::operator*=;
-%ignore aiMatrix3x3::operator==;
-%ignore aiMatrix3x3::operator[];
-
-/////// aiMatrix4x4 
-%ignore aiMatrix4x4::operator!=;
-%ignore aiMatrix4x4::operator*;
-%ignore aiMatrix4x4::operator*=;
-%ignore aiMatrix4x4::operator==;
-%ignore aiMatrix4x4::operator[];
-
-/////// aiMesh 
-ASSIMP_POINTER_POINTER(aiMesh,aiAnimMesh,mAnimMeshes,$self->mNumAnimMeshes);
-ASSIMP_POINTER_ARRAY(aiMesh,aiVector3D,mBitangents,$self->mNumVertices);
-ASSIMP_POINTER_POINTER(aiMesh,aiBone,mBones,$self->mNumBones);
-ASSIMP_POINTER_ARRAY_ARRAY(aiMesh,aiColor4D,mColors,AI_MAX_NUMBER_OF_COLOR_SETS,$self->mNumVertices);
-ASSIMP_POINTER_ARRAY(aiMesh,aiFace,mFaces,$self->mNumFaces);
-ASSIMP_POINTER_ARRAY(aiMesh,aiVector3D,mNormals,$self->mNumVertices);
-ASSIMP_POINTER_ARRAY(aiMesh,aiVector3D,mTangents,$self->mNumVertices);
-ASSIMP_POINTER_ARRAY_ARRAY(aiMesh,aiVector3D,mTextureCoords,AI_MAX_NUMBER_OF_TEXTURECOORDS,$self->mNumVertices);
-ASSIMP_ARRAY(aiMesh,unsigned int,mNumUVComponents,AI_MAX_NUMBER_OF_TEXTURECOORDS);
-ASSIMP_POINTER_ARRAY(aiMesh,aiVector3D,mVertices,$self->mNumVertices);
-%typemap(cstype)   unsigned int mPrimitiveTypes "aiPrimitiveType";
-%typemap(csin)     unsigned int mPrimitiveTypes "(uint)$csinput";
-%typemap(csvarout) unsigned int mPrimitiveTypes %{ get { return (aiPrimitiveType)$imcall; } %}
-%typemap(cscode) aiMesh %{
-  public aiVector3DVector mBitangents { get { return GetmBitangents(); } }
-  public aiBoneVector mBones { get { return GetmBones(); } }
-  public aiColor4DVectorVector mColors { get { return GetmColors(); } }
-  public aiFaceVector mFaces { get { return GetmFaces(); } }
-  public aiVector3DVector mNormals { get { return GetmNormals(); } }
-  public aiVector3DVector mTangents { get { return GetmTangents(); } }
-  public aiVector3DVectorVector mTextureCoords { get { return GetmTextureCoords(); } }
-  public aiVector3DVector mVertices { get { return GetmVertices(); } }
-%}
-
-/////// aiMeshAnim 
-ASSIMP_POINTER_ARRAY(aiMeshAnim,aiMeshKey,mKeys,$self->mNumKeys);
-%typemap(cscode) aiMeshAnim %{
-  public aiMeshKeyVector mKeys { get { return GetmKeys(); } }
-%}
-
-/////// aiMeshKey 
-// Done
-
-/////// aiNode 
-ASSIMP_POINTER_POINTER(aiNode,aiNode,mChildren,$self->mNumChildren);
-ASSIMP_ARRAY(aiNode,unsigned int,mMeshes,$self->mNumMeshes);
-%typemap(cscode) aiNode %{
-  public aiNodeVector mChildren { get { return GetmChildren(); } }
-  public UintVector mMeshes { get { return GetmMeshes(); } }
-%}
-
-/////// aiNodeAnim 
-ASSIMP_POINTER_ARRAY(aiNodeAnim,aiVectorKey,mPositionKeys,$self->mNumPositionKeys);
-ASSIMP_POINTER_ARRAY(aiNodeAnim,aiQuatKey,mRotationKeys,$self->mNumRotationKeys);
-ASSIMP_POINTER_ARRAY(aiNodeAnim,aiVectorKey,mScalingKeys,$self->mNumScalingKeys);
-%typemap(cscode) aiNodeAnim %{
-  public aiVectorKeyVector mPositionKeys { get { return GetmPositionKeys(); } }
-  public aiQuatKeyVector mRotationKeys { get { return GetmRotationKeys(); } }
-  public aiVectorKeyVector mScalingKeys { get { return GetmScalingKeys(); } }
-%}
-
-/////// aiPlane 
-// Done
-
-/////// aiPostProcessSteps
-%typemap(cscode) aiPostProcessSteps %{
-	, aiProcess_ConvertToLeftHanded = aiProcess_MakeLeftHanded|aiProcess_FlipUVs|aiProcess_FlipWindingOrder,
-%}
-
-/////// aiQuaternion 
-// Done
-
-/////// aiQuatKey 
-// Done
-
-/////// aiRay 
-// Done
-
-/////// aiScene 
-ASSIMP_POINTER_POINTER(aiScene,aiAnimation,mAnimations,$self->mNumAnimations);
-ASSIMP_POINTER_POINTER(aiScene,aiCamera,mCameras,$self->mNumCameras);
-ASSIMP_POINTER_POINTER(aiScene,aiLight,mLights,$self->mNumLights);
-ASSIMP_POINTER_POINTER(aiScene,aiMaterial,mMaterials,$self->mNumMaterials);
-ASSIMP_POINTER_POINTER(aiScene,aiMesh,mMeshes,$self->mNumMeshes);
-ASSIMP_POINTER_POINTER(aiScene,aiTexture,mTextures,$self->mNumTextures);
-%typemap(cscode) aiScene %{
-  public aiAnimationVector mAnimations { get { return GetmAnimations(); } }
-  public aiCameraVector mCameras { get { return GetmCameras(); } }
-  public aiLightVector mLights { get { return GetmLights(); } }
-  public aiMaterialVector mMaterials { get { return GetmMaterials(); } }
-  public aiMeshVector mMeshes { get { return GetmMeshes(); } }
-  public aiTextureVector mTextures { get { return GetmTextures(); } }
-%}
-
-/////// aiString 
-%ignore aiString::Append;
-%ignore aiString::Clear;
-%ignore aiString::Set;
-%rename(Data) aiString::data;
-%rename(Length) aiString::length;
-%typemap(cscode) aiString %{
-  public override string ToString() { return Data; } 
-%}
-
-
-/////// aiTexel 
-// Done
-
-/////// TODO: aiTexture 
-%ignore aiString::achFormatHint;
-%ignore aiString::pcData;
-
-/////// aiUVTransform 
-// Done
-
-/////// aiVector2D 
-// Done
-
-/////// aiVector3D 
-// Done
-
-/////// aiVectorKey 
-// Done
-
-/////// aiVertexWeight 
-// Done
-
-/////// Assimp::*
-%ignore Assimp::IOStream;
-%ignore Assimp::IOSystem;
-%ignore Assimp::Importer::ApplyPostProcessing;
-%ignore Assimp::Importer::FindLoader;
-%ignore Assimp::Importer::GetIOHandler;
-%ignore Assimp::Importer::GetExtensionList(std::string&);
-%ignore Assimp::Importer::GetExtensionList(aiString&);
-%ignore Assimp::Importer::ReadFileFromMemory;
-%ignore Assimp::Importer::RegisterLoader;
-%ignore Assimp::Importer::RegisterPPStep;
-%ignore Assimp::Importer::SetIOHandler;
-%ignore Assimp::Importer::SetPropertyInteger;
-%ignore Assimp::Importer::SetPropertyFloat;
-%ignore Assimp::Importer::SetPropertyString;
-%ignore Assimp::Importer::SetPropertyBool;
-%ignore Assimp::Importer::UnregisterLoader;
-%ignore Assimp::Importer::UnregisterPPStep;
-%extend Assimp::Importer {
-  std::string GetExtensionList() {
-    std::string tmp;
-    $self->GetExtensionList(tmp);
-    return tmp;
-  }
-}
-%typemap(cstype)   unsigned int pFlags "aiPostProcessSteps";
-%typemap(csin)     unsigned int pFlags "(uint)$csinput"
-%typemap(csvarout) unsigned int pFlags %{ get { return (aiPostProcessSteps)$imcall; } %}
-%ignore Assimp::Logger;
-%ignore Assimp::NullLogger;
-
-/////// Globals
-%ignore ::aiImportFileEx;
-%ignore ::aiImportFileEx;
-%ignore ::aiGetMaterialProperty;
-%ignore ::aiGetMaterialFloatArray;
-%ignore ::aiGetMaterialFloat;
-%ignore ::aiGetMaterialIntegerArray;
-%ignore ::aiGetMaterialInteger;
-%ignore ::aiGetMaterialColor;
-%ignore ::aiGetMaterialString;
-%ignore ::aiGetMaterialTextureCount;
-%ignore ::aiGetMaterialTexture;
-
-
-%include "..\..\..\include\assimp\defs.h"
-%include "..\..\..\include\assimp\config.h"
-%include "..\..\..\include\assimp\types.h"
-%include "..\..\..\include\assimp\version.h"
-%include "..\..\..\include\assimp\postprocess.h"
-%include "..\..\..\include\assimp\vector2.h"
-%include "..\..\..\include\assimp\vector3.h"
-%include "..\..\..\include\assimp\color4.h"
-%include "..\..\..\include\assimp\matrix3x3.h"
-%include "..\..\..\include\assimp\matrix4x4.h"
-%include "..\..\..\include\assimp\camera.h"
-%include "..\..\..\include\assimp\light.h"
-%include "..\..\..\include\assimp\anim.h"
-%include "..\..\..\include\assimp\mesh.h"
-%include "..\..\..\include\assimp\cfileio.h"
-%include "..\..\..\include\assimp\material.h"
-%include "..\..\..\include\assimp\quaternion.h"
-%include "..\..\..\include\assimp\scene.h"
-%include "..\..\..\include\assimp\texture.h"
-%include "..\..\..\include\assimp\Importer.hpp"
-%include "..\..\..\include\assimp\ProgressHandler.hpp"
-//%include "..\..\..\include\IOSystem.h"
-//%include "..\..\..\include\IOStream.h"
-//%include "..\..\..\include\Logger.h"
-//%include "..\..\..\include\LogStream.h"
-//%include "..\..\..\include\NullLogger.h"
-
-
-%template(aiColor4D) aiColor4t<float>;
-
-%template(aiVector3D) aiVector3t<float>;
-%template(aiVector2D) aiVector2t<float>;
-
-%template(aiQuaternion) aiQuaterniont<float>;
-%template(aiMatrix3x3) aiMatrix3x3t<float>;
-%template(aiMatrix4x4) aiMatrix4x4t<float>;
-
-%template(FloatVector) std::vector<float>;
-%template(UintVector) std::vector<unsigned int>;
-%template(aiAnimationVector) std::vector<aiAnimation *>;
-%template(aiAnimMeshVector) std::vector<aiAnimMesh *>;
-%template(aiBoneVector) std::vector<aiBone *>;
-%template(aiCameraVector) std::vector<aiCamera *>;
-%template(aiColor4DVectorVector) std::vector<std::vector<aiColor4D *> >;
-%template(aiColor4DVector) std::vector<aiColor4D *>;
-%template(aiFaceVector) std::vector<aiFace *>;
-%template(aiLightVector) std::vector<aiLight *>;
-%template(aiMaterialVector) std::vector<aiMaterial *>;
-%template(aiMeshAnimVector) std::vector<aiMeshAnim *>;
-%template(aiMeshKeyVector) std::vector<aiMeshKey *>;
-%template(aiMeshVector) std::vector<aiMesh *>;
-%template(aiNodeVector) std::vector<aiNode *>;
-%template(aiNodeAnimVector) std::vector<aiNodeAnim *>;
-%template(aiQuatKeyVector) std::vector<aiQuatKey *>;
-%template(aiTextureVector) std::vector<aiTexture *>;
-%template(aiVector3DVector) std::vector<aiVector3D *>;
-%template(aiVector3DVectorVector) std::vector<std::vector<aiVector3D *> >;
-%template(aiVectorKeyVector) std::vector<aiVectorKey *>;
-%template(aiVertexWeightVector) std::vector<aiVertexWeight *>;
-

port/Assimp.NET/Assimp.NET_CS/Assimp.NET_CS.csproj

@@ -1,176 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>9.0.21022</ProductVersion>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>Assimp</RootNamespace>
-    <AssemblyName>Assimp.Interop</AssemblyName>
-    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <TargetFrameworkSubset>
-    </TargetFrameworkSubset>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>..\..\..\bin\%24%28ProjectName%29_%24%28ConfigurationName%29_%24%28PlatformName%29\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\x86\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>x86</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
-    <OutputPath>bin\x86\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x86</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="Microsoft.DirectX, Version=1.0.2902.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
-    <Reference Include="System" />
-    <Reference Include="System.Core">
-      <RequiredTargetFramework>3.5</RequiredTargetFramework>
-    </Reference>
-    <Reference Include="System.Xml.Linq">
-      <RequiredTargetFramework>3.5</RequiredTargetFramework>
-    </Reference>
-    <Reference Include="System.Data.DataSetExtensions">
-      <RequiredTargetFramework>3.5</RequiredTargetFramework>
-    </Reference>
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\Assimp.NET\Assimp.NET.vcproj">
-      <Project>{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}</Project>
-      <Name>Assimp_NET</Name>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="aiAnimation.cs" />
-    <Compile Include="aiAnimationVector.cs" />
-    <Compile Include="aiAnimBehaviour.cs" />
-    <Compile Include="aiAnimMesh.cs" />
-    <Compile Include="aiAnimMeshVector.cs" />
-    <Compile Include="aiBlendMode.cs" />
-    <Compile Include="aiBone.cs" />
-    <Compile Include="aiBoneVector.cs" />
-    <Compile Include="aiCamera.cs" />
-    <Compile Include="aiCameraVector.cs" />
-    <Compile Include="aiColor3D.cs" />
-    <Compile Include="aiColor4D.cs" />
-    <Compile Include="aiColor4DVector.cs" />
-    <Compile Include="aiColor4DVectorVector.cs" />
-    <Compile Include="aiComponent.cs" />
-    <Compile Include="aiDefaultLogStream.cs" />
-    <Compile Include="aiFace.cs" />
-    <Compile Include="aiFaceVector.cs" />
-    <Compile Include="aiLight.cs" />
-    <Compile Include="aiLightSourceType.cs" />
-    <Compile Include="aiLightVector.cs" />
-    <Compile Include="aiMaterial.cs" />
-    <Compile Include="aiMaterialProperty.cs" />
-    <Compile Include="aiMaterialVector.cs" />
-    <Compile Include="aiMatrix3x3.cs" />
-    <Compile Include="aiMatrix4x4.cs" />
-    <Compile Include="aiMemoryInfo.cs" />
-    <Compile Include="aiMesh.cs" />
-    <Compile Include="aiMeshAnim.cs" />
-    <Compile Include="aiMeshAnimVector.cs" />
-    <Compile Include="aiMeshKey.cs" />
-    <Compile Include="aiMeshKeyVector.cs" />
-    <Compile Include="aiMeshVector.cs" />
-    <Compile Include="aiNode.cs" />
-    <Compile Include="aiNodeAnim.cs" />
-    <Compile Include="aiNodeAnimVector.cs" />
-    <Compile Include="aiNodeVector.cs" />
-    <Compile Include="aiOrigin.cs" />
-    <Compile Include="aiPlane.cs" />
-    <Compile Include="aiPostProcessSteps.cs" />
-    <Compile Include="aiPrimitiveType.cs" />
-    <Compile Include="aiPropertyTypeInfo.cs" />
-    <Compile Include="aiQuaternion.cs" />
-    <Compile Include="aiQuatKey.cs" />
-    <Compile Include="aiQuatKeyVector.cs" />
-    <Compile Include="aiRay.cs" />
-    <Compile Include="aiReturn.cs" />
-    <Compile Include="aiScene.cs" />
-    <Compile Include="aiShadingMode.cs" />
-    <Compile Include="aiString.cs" />
-    <Compile Include="aiTexel.cs" />
-    <Compile Include="aiTexture.cs" />
-    <Compile Include="aiTextureFlags.cs" />
-    <Compile Include="aiTextureMapMode.cs" />
-    <Compile Include="aiTextureMapping.cs" />
-    <Compile Include="aiTextureOp.cs" />
-    <Compile Include="aiTextureType.cs" />
-    <Compile Include="aiTextureVector.cs" />
-    <Compile Include="aiUVTransform.cs" />
-    <Compile Include="aiVector2D.cs" />
-    <Compile Include="aiVector3D.cs" />
-    <Compile Include="aiVector3DVector.cs" />
-    <Compile Include="aiVector3DVectorVector.cs" />
-    <Compile Include="aiVectorKey.cs" />
-    <Compile Include="aiVectorKeyVector.cs" />
-    <Compile Include="aiVertexWeight.cs" />
-    <Compile Include="aiVertexWeightVector.cs" />
-    <Compile Include="Assimp.cs" />
-    <Compile Include="AssimpPINVOKE.cs" />
-    <Compile Include="FloatVector.cs" />
-    <Compile Include="Importer.cs" />
-    <Compile Include="ProgressHandler.cs" />
-    <Compile Include="SWIGTYPE_p_aiImporterDesc.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="SWIGTYPE_p_Assimp__BaseImporter.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="SWIGTYPE_p_Assimp__ImporterPimpl.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="SWIGTYPE_p_float.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="SWIGTYPE_p_std__string.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="SWIGTYPE_p_void.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="UintVector.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Properties\" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>

port/Assimp.NET/Assimp.NET_CS/Assimp.cs

@@ -1,137 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class Assimp {
-  public static uint MAXLEN {
-    get {
-      uint ret = AssimpPINVOKE.MAXLEN_get();
-      return ret;
-    } 
-  }
-
-  public static string aiGetLegalString() {
-    string ret = AssimpPINVOKE.aiGetLegalString();
-    return ret;
-  }
-
-  public static uint aiGetVersionMinor() {
-    uint ret = AssimpPINVOKE.aiGetVersionMinor();
-    return ret;
-  }
-
-  public static uint aiGetVersionMajor() {
-    uint ret = AssimpPINVOKE.aiGetVersionMajor();
-    return ret;
-  }
-
-  public static uint aiGetVersionRevision() {
-    uint ret = AssimpPINVOKE.aiGetVersionRevision();
-    return ret;
-  }
-
-  public static uint aiGetCompileFlags() {
-    uint ret = AssimpPINVOKE.aiGetCompileFlags();
-    return ret;
-  }
-
-  public static readonly double AI_MATH_PI = AssimpPINVOKE.AI_MATH_PI_get();
-  public static readonly double AI_MATH_TWO_PI = AssimpPINVOKE.AI_MATH_TWO_PI_get();
-  public static readonly double AI_MATH_HALF_PI = AssimpPINVOKE.AI_MATH_HALF_PI_get();
-  public static readonly double AI_MATH_PI_F = AssimpPINVOKE.AI_MATH_PI_F_get();
-  public static readonly double AI_MATH_TWO_PI_F = AssimpPINVOKE.AI_MATH_TWO_PI_F_get();
-  public static readonly double AI_MATH_HALF_PI_F = AssimpPINVOKE.AI_MATH_HALF_PI_F_get();
-  public static readonly string AI_CONFIG_GLOB_MEASURE_TIME = AssimpPINVOKE.AI_CONFIG_GLOB_MEASURE_TIME_get();
-  public static readonly string AI_CONFIG_PP_SBBC_MAX_BONES = AssimpPINVOKE.AI_CONFIG_PP_SBBC_MAX_BONES_get();
-  public static readonly int AI_SBBC_DEFAULT_MAX_BONES = AssimpPINVOKE.AI_SBBC_DEFAULT_MAX_BONES_get();
-  public static readonly string AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE = AssimpPINVOKE.AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE_get();
-  public static readonly string AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX = AssimpPINVOKE.AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX_get();
-  public static readonly string AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE = AssimpPINVOKE.AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE_get();
-  public static readonly string AI_CONFIG_IMPORT_MDL_COLORMAP = AssimpPINVOKE.AI_CONFIG_IMPORT_MDL_COLORMAP_get();
-  public static readonly string AI_CONFIG_PP_RRM_EXCLUDE_LIST = AssimpPINVOKE.AI_CONFIG_PP_RRM_EXCLUDE_LIST_get();
-  public static readonly string AI_CONFIG_PP_PTV_KEEP_HIERARCHY = AssimpPINVOKE.AI_CONFIG_PP_PTV_KEEP_HIERARCHY_get();
-  public static readonly string AI_CONFIG_PP_PTV_NORMALIZE = AssimpPINVOKE.AI_CONFIG_PP_PTV_NORMALIZE_get();
-  public static readonly string AI_CONFIG_PP_FD_REMOVE = AssimpPINVOKE.AI_CONFIG_PP_FD_REMOVE_get();
-  public static readonly string AI_CONFIG_PP_OG_EXCLUDE_LIST = AssimpPINVOKE.AI_CONFIG_PP_OG_EXCLUDE_LIST_get();
-  public static readonly string AI_CONFIG_PP_SLM_TRIANGLE_LIMIT = AssimpPINVOKE.AI_CONFIG_PP_SLM_TRIANGLE_LIMIT_get();
-  public static readonly int AI_SLM_DEFAULT_MAX_TRIANGLES = AssimpPINVOKE.AI_SLM_DEFAULT_MAX_TRIANGLES_get();
-  public static readonly string AI_CONFIG_PP_SLM_VERTEX_LIMIT = AssimpPINVOKE.AI_CONFIG_PP_SLM_VERTEX_LIMIT_get();
-  public static readonly int AI_SLM_DEFAULT_MAX_VERTICES = AssimpPINVOKE.AI_SLM_DEFAULT_MAX_VERTICES_get();
-  public static readonly string AI_CONFIG_PP_LBW_MAX_WEIGHTS = AssimpPINVOKE.AI_CONFIG_PP_LBW_MAX_WEIGHTS_get();
-  public static readonly int AI_LMW_MAX_WEIGHTS = AssimpPINVOKE.AI_LMW_MAX_WEIGHTS_get();
-  public static readonly string AI_CONFIG_PP_DB_THRESHOLD = AssimpPINVOKE.AI_CONFIG_PP_DB_THRESHOLD_get();
-  public static readonly double AI_DEBONE_THRESHOLD = AssimpPINVOKE.AI_DEBONE_THRESHOLD_get();
-  public static readonly string AI_CONFIG_PP_DB_ALL_OR_NONE = AssimpPINVOKE.AI_CONFIG_PP_DB_ALL_OR_NONE_get();
-  public static readonly int PP_ICL_PTCACHE_SIZE = AssimpPINVOKE.PP_ICL_PTCACHE_SIZE_get();
-  public static readonly string AI_CONFIG_PP_ICL_PTCACHE_SIZE = AssimpPINVOKE.AI_CONFIG_PP_ICL_PTCACHE_SIZE_get();
-  public static readonly string AI_CONFIG_PP_RVC_FLAGS = AssimpPINVOKE.AI_CONFIG_PP_RVC_FLAGS_get();
-  public static readonly string AI_CONFIG_PP_SBP_REMOVE = AssimpPINVOKE.AI_CONFIG_PP_SBP_REMOVE_get();
-  public static readonly string AI_CONFIG_PP_FID_ANIM_ACCURACY = AssimpPINVOKE.AI_CONFIG_PP_FID_ANIM_ACCURACY_get();
-  public static readonly int AI_UVTRAFO_SCALING = AssimpPINVOKE.AI_UVTRAFO_SCALING_get();
-  public static readonly int AI_UVTRAFO_ROTATION = AssimpPINVOKE.AI_UVTRAFO_ROTATION_get();
-  public static readonly int AI_UVTRAFO_TRANSLATION = AssimpPINVOKE.AI_UVTRAFO_TRANSLATION_get();
-  public static readonly int AI_UVTRAFO_ALL = AssimpPINVOKE.AI_UVTRAFO_ALL_get();
-  public static readonly string AI_CONFIG_PP_TUV_EVALUATE = AssimpPINVOKE.AI_CONFIG_PP_TUV_EVALUATE_get();
-  public static readonly string AI_CONFIG_FAVOUR_SPEED = AssimpPINVOKE.AI_CONFIG_FAVOUR_SPEED_get();
-  public static readonly string AI_CONFIG_IMPORT_GLOBAL_KEYFRAME = AssimpPINVOKE.AI_CONFIG_IMPORT_GLOBAL_KEYFRAME_get();
-  public static readonly string AI_CONFIG_IMPORT_MD3_KEYFRAME = AssimpPINVOKE.AI_CONFIG_IMPORT_MD3_KEYFRAME_get();
-  public static readonly string AI_CONFIG_IMPORT_MD2_KEYFRAME = AssimpPINVOKE.AI_CONFIG_IMPORT_MD2_KEYFRAME_get();
-  public static readonly string AI_CONFIG_IMPORT_MDL_KEYFRAME = AssimpPINVOKE.AI_CONFIG_IMPORT_MDL_KEYFRAME_get();
-  public static readonly string AI_CONFIG_IMPORT_MDC_KEYFRAME = AssimpPINVOKE.AI_CONFIG_IMPORT_MDC_KEYFRAME_get();
-  public static readonly string AI_CONFIG_IMPORT_SMD_KEYFRAME = AssimpPINVOKE.AI_CONFIG_IMPORT_SMD_KEYFRAME_get();
-  public static readonly string AI_CONFIG_IMPORT_UNREAL_KEYFRAME = AssimpPINVOKE.AI_CONFIG_IMPORT_UNREAL_KEYFRAME_get();
-  public static readonly string AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL = AssimpPINVOKE.AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL_get();
-  public static readonly string AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION = AssimpPINVOKE.AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION_get();
-  public static readonly string AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS = AssimpPINVOKE.AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS_get();
-  public static readonly string AI_CONFIG_IMPORT_TER_MAKE_UVS = AssimpPINVOKE.AI_CONFIG_IMPORT_TER_MAKE_UVS_get();
-  public static readonly string AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS = AssimpPINVOKE.AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS_get();
-  public static readonly string AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART = AssimpPINVOKE.AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART_get();
-  public static readonly string AI_CONFIG_IMPORT_MD3_SKIN_NAME = AssimpPINVOKE.AI_CONFIG_IMPORT_MD3_SKIN_NAME_get();
-  public static readonly string AI_CONFIG_IMPORT_MD3_SHADER_SRC = AssimpPINVOKE.AI_CONFIG_IMPORT_MD3_SHADER_SRC_get();
-  public static readonly string AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY = AssimpPINVOKE.AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY_get();
-  public static readonly string AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD = AssimpPINVOKE.AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD_get();
-  public static readonly string AI_CONFIG_IMPORT_LWS_ANIM_START = AssimpPINVOKE.AI_CONFIG_IMPORT_LWS_ANIM_START_get();
-  public static readonly string AI_CONFIG_IMPORT_LWS_ANIM_END = AssimpPINVOKE.AI_CONFIG_IMPORT_LWS_ANIM_END_get();
-  public static readonly string AI_CONFIG_IMPORT_IRR_ANIM_FPS = AssimpPINVOKE.AI_CONFIG_IMPORT_IRR_ANIM_FPS_get();
-  public static readonly string AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE = AssimpPINVOKE.AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE_get();
-  public static readonly string AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME = AssimpPINVOKE.AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME_get();
-  public static readonly string AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS = AssimpPINVOKE.AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS_get();
-  public static readonly string AI_CONFIG_IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS = AssimpPINVOKE.AI_CONFIG_IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS_get();
-  public static readonly string AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION = AssimpPINVOKE.AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION_get();
-  public static readonly int ASSIMP_CFLAGS_SHARED = AssimpPINVOKE.ASSIMP_CFLAGS_SHARED_get();
-  public static readonly int ASSIMP_CFLAGS_STLPORT = AssimpPINVOKE.ASSIMP_CFLAGS_STLPORT_get();
-  public static readonly int ASSIMP_CFLAGS_DEBUG = AssimpPINVOKE.ASSIMP_CFLAGS_DEBUG_get();
-  public static readonly int ASSIMP_CFLAGS_NOBOOST = AssimpPINVOKE.ASSIMP_CFLAGS_NOBOOST_get();
-  public static readonly int ASSIMP_CFLAGS_SINGLETHREADED = AssimpPINVOKE.ASSIMP_CFLAGS_SINGLETHREADED_get();
-  public static readonly int AI_MAX_FACE_INDICES = AssimpPINVOKE.AI_MAX_FACE_INDICES_get();
-  public static readonly int AI_MAX_BONE_WEIGHTS = AssimpPINVOKE.AI_MAX_BONE_WEIGHTS_get();
-  public static readonly int AI_MAX_VERTICES = AssimpPINVOKE.AI_MAX_VERTICES_get();
-  public static readonly int AI_MAX_FACES = AssimpPINVOKE.AI_MAX_FACES_get();
-  public static readonly int AI_MAX_NUMBER_OF_COLOR_SETS = AssimpPINVOKE.AI_MAX_NUMBER_OF_COLOR_SETS_get();
-  public static readonly int AI_MAX_NUMBER_OF_TEXTURECOORDS = AssimpPINVOKE.AI_MAX_NUMBER_OF_TEXTURECOORDS_get();
-  public static readonly string AI_DEFAULT_MATERIAL_NAME = AssimpPINVOKE.AI_DEFAULT_MATERIAL_NAME_get();
-  public static readonly string _AI_MATKEY_TEXTURE_BASE = AssimpPINVOKE._AI_MATKEY_TEXTURE_BASE_get();
-  public static readonly string _AI_MATKEY_UVWSRC_BASE = AssimpPINVOKE._AI_MATKEY_UVWSRC_BASE_get();
-  public static readonly string _AI_MATKEY_TEXOP_BASE = AssimpPINVOKE._AI_MATKEY_TEXOP_BASE_get();
-  public static readonly string _AI_MATKEY_MAPPING_BASE = AssimpPINVOKE._AI_MATKEY_MAPPING_BASE_get();
-  public static readonly string _AI_MATKEY_TEXBLEND_BASE = AssimpPINVOKE._AI_MATKEY_TEXBLEND_BASE_get();
-  public static readonly string _AI_MATKEY_MAPPINGMODE_U_BASE = AssimpPINVOKE._AI_MATKEY_MAPPINGMODE_U_BASE_get();
-  public static readonly string _AI_MATKEY_MAPPINGMODE_V_BASE = AssimpPINVOKE._AI_MATKEY_MAPPINGMODE_V_BASE_get();
-  public static readonly string _AI_MATKEY_TEXMAP_AXIS_BASE = AssimpPINVOKE._AI_MATKEY_TEXMAP_AXIS_BASE_get();
-  public static readonly string _AI_MATKEY_UVTRANSFORM_BASE = AssimpPINVOKE._AI_MATKEY_UVTRANSFORM_BASE_get();
-  public static readonly string _AI_MATKEY_TEXFLAGS_BASE = AssimpPINVOKE._AI_MATKEY_TEXFLAGS_BASE_get();
-  public static readonly int AI_SCENE_FLAGS_INCOMPLETE = AssimpPINVOKE.AI_SCENE_FLAGS_INCOMPLETE_get();
-  public static readonly int AI_SCENE_FLAGS_VALIDATED = AssimpPINVOKE.AI_SCENE_FLAGS_VALIDATED_get();
-  public static readonly int AI_SCENE_FLAGS_VALIDATION_WARNING = AssimpPINVOKE.AI_SCENE_FLAGS_VALIDATION_WARNING_get();
-  public static readonly int AI_SCENE_FLAGS_NON_VERBOSE_FORMAT = AssimpPINVOKE.AI_SCENE_FLAGS_NON_VERBOSE_FORMAT_get();
-  public static readonly int AI_SCENE_FLAGS_TERRAIN = AssimpPINVOKE.AI_SCENE_FLAGS_TERRAIN_get();
-  public static readonly int AI_PROPERTY_WAS_NOT_EXISTING = AssimpPINVOKE.AI_PROPERTY_WAS_NOT_EXISTING_get();
-}

port/Assimp.NET/Assimp.NET_CS/FloatVector.cs

@@ -1,346 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class FloatVector : IDisposable, System.Collections.IEnumerable
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IList<float>
-#endif
- {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal FloatVector(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(FloatVector obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~FloatVector() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_FloatVector(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public FloatVector(System.Collections.ICollection c) : this() {
-    if (c == null)
-      throw new ArgumentNullException("c");
-    foreach (float element in c) {
-      this.Add(element);
-    }
-  }
-
-  public bool IsFixedSize {
-    get {
-      return false;
-    }
-  }
-
-  public bool IsReadOnly {
-    get {
-      return false;
-    }
-  }
-
-  public float this[int index]  {
-    get {
-      return getitem(index);
-    }
-    set {
-      setitem(index, value);
-    }
-  }
-
-  public int Capacity {
-    get {
-      return (int)capacity();
-    }
-    set {
-      if (value < size())
-        throw new ArgumentOutOfRangeException("Capacity");
-      reserve((uint)value);
-    }
-  }
-
-  public int Count {
-    get {
-      return (int)size();
-    }
-  }
-
-  public bool IsSynchronized {
-    get {
-      return false;
-    }
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(System.Array array)
-#else
-  public void CopyTo(float[] array)
-#endif
-  {
-    CopyTo(0, array, 0, this.Count);
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(System.Array array, int arrayIndex)
-#else
-  public void CopyTo(float[] array, int arrayIndex)
-#endif
-  {
-    CopyTo(0, array, arrayIndex, this.Count);
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(int index, System.Array array, int arrayIndex, int count)
-#else
-  public void CopyTo(int index, float[] array, int arrayIndex, int count)
-#endif
-  {
-    if (array == null)
-      throw new ArgumentNullException("array");
-    if (index < 0)
-      throw new ArgumentOutOfRangeException("index", "Value is less than zero");
-    if (arrayIndex < 0)
-      throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
-    if (count < 0)
-      throw new ArgumentOutOfRangeException("count", "Value is less than zero");
-    if (array.Rank > 1)
-      throw new ArgumentException("Multi dimensional array.", "array");
-    if (index+count > this.Count || arrayIndex+count > array.Length)
-      throw new ArgumentException("Number of elements to copy is too large.");
-    for (int i=0; i<count; i++)
-      array.SetValue(getitemcopy(index+i), arrayIndex+i);
-  }
-
-#if !SWIG_DOTNET_1
-  System.Collections.Generic.IEnumerator<float> System.Collections.Generic.IEnumerable<float>.GetEnumerator() {
-    return new FloatVectorEnumerator(this);
-  }
-#endif
-
-  System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
-    return new FloatVectorEnumerator(this);
-  }
-
-  public FloatVectorEnumerator GetEnumerator() {
-    return new FloatVectorEnumerator(this);
-  }
-
-  // Type-safe enumerator
-  /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
-  /// whenever the collection is modified. This has been done for changes in the size of the
-  /// collection but not when one of the elements of the collection is modified as it is a bit
-  /// tricky to detect unmanaged code that modifies the collection under our feet.
-  public sealed class FloatVectorEnumerator : System.Collections.IEnumerator
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IEnumerator<float>
-#endif
-  {
-    private FloatVector collectionRef;
-    private int currentIndex;
-    private object currentObject;
-    private int currentSize;
-
-    public FloatVectorEnumerator(FloatVector collection) {
-      collectionRef = collection;
-      currentIndex = -1;
-      currentObject = null;
-      currentSize = collectionRef.Count;
-    }
-
-    // Type-safe iterator Current
-    public float Current {
-      get {
-        if (currentIndex == -1)
-          throw new InvalidOperationException("Enumeration not started.");
-        if (currentIndex > currentSize - 1)
-          throw new InvalidOperationException("Enumeration finished.");
-        if (currentObject == null)
-          throw new InvalidOperationException("Collection modified.");
-        return (float)currentObject;
-      }
-    }
-
-    // Type-unsafe IEnumerator.Current
-    object System.Collections.IEnumerator.Current {
-      get {
-        return Current;
-      }
-    }
-
-    public bool MoveNext() {
-      int size = collectionRef.Count;
-      bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
-      if (moveOkay) {
-        currentIndex++;
-        currentObject = collectionRef[currentIndex];
-      } else {
-        currentObject = null;
-      }
-      return moveOkay;
-    }
-
-    public void Reset() {
-      currentIndex = -1;
-      currentObject = null;
-      if (collectionRef.Count != currentSize) {
-        throw new InvalidOperationException("Collection modified.");
-      }
-    }
-
-#if !SWIG_DOTNET_1
-    public void Dispose() {
-        currentIndex = -1;
-        currentObject = null;
-    }
-#endif
-  }
-
-  public void Clear() {
-    AssimpPINVOKE.FloatVector_Clear(swigCPtr);
-  }
-
-  public void Add(float x) {
-    AssimpPINVOKE.FloatVector_Add(swigCPtr, x);
-  }
-
-  private uint size() {
-    uint ret = AssimpPINVOKE.FloatVector_size(swigCPtr);
-    return ret;
-  }
-
-  private uint capacity() {
-    uint ret = AssimpPINVOKE.FloatVector_capacity(swigCPtr);
-    return ret;
-  }
-
-  private void reserve(uint n) {
-    AssimpPINVOKE.FloatVector_reserve(swigCPtr, n);
-  }
-
-  public FloatVector() : this(AssimpPINVOKE.new_FloatVector__SWIG_0(), true) {
-  }
-
-  public FloatVector(FloatVector other) : this(AssimpPINVOKE.new_FloatVector__SWIG_1(FloatVector.getCPtr(other)), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public FloatVector(int capacity) : this(AssimpPINVOKE.new_FloatVector__SWIG_2(capacity), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  private float getitemcopy(int index) {
-    float ret = AssimpPINVOKE.FloatVector_getitemcopy(swigCPtr, index);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private float getitem(int index) {
-    float ret = AssimpPINVOKE.FloatVector_getitem(swigCPtr, index);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private void setitem(int index, float val) {
-    AssimpPINVOKE.FloatVector_setitem(swigCPtr, index, val);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void AddRange(FloatVector values) {
-    AssimpPINVOKE.FloatVector_AddRange(swigCPtr, FloatVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public FloatVector GetRange(int index, int count) {
-    IntPtr cPtr = AssimpPINVOKE.FloatVector_GetRange(swigCPtr, index, count);
-    FloatVector ret = (cPtr == IntPtr.Zero) ? null : new FloatVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Insert(int index, float x) {
-    AssimpPINVOKE.FloatVector_Insert(swigCPtr, index, x);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void InsertRange(int index, FloatVector values) {
-    AssimpPINVOKE.FloatVector_InsertRange(swigCPtr, index, FloatVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveAt(int index) {
-    AssimpPINVOKE.FloatVector_RemoveAt(swigCPtr, index);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveRange(int index, int count) {
-    AssimpPINVOKE.FloatVector_RemoveRange(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public static FloatVector Repeat(float value, int count) {
-    IntPtr cPtr = AssimpPINVOKE.FloatVector_Repeat(value, count);
-    FloatVector ret = (cPtr == IntPtr.Zero) ? null : new FloatVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Reverse() {
-    AssimpPINVOKE.FloatVector_Reverse__SWIG_0(swigCPtr);
-  }
-
-  public void Reverse(int index, int count) {
-    AssimpPINVOKE.FloatVector_Reverse__SWIG_1(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void SetRange(int index, FloatVector values) {
-    AssimpPINVOKE.FloatVector_SetRange(swigCPtr, index, FloatVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public bool Contains(float value) {
-    bool ret = AssimpPINVOKE.FloatVector_Contains(swigCPtr, value);
-    return ret;
-  }
-
-  public int IndexOf(float value) {
-    int ret = AssimpPINVOKE.FloatVector_IndexOf(swigCPtr, value);
-    return ret;
-  }
-
-  public int LastIndexOf(float value) {
-    int ret = AssimpPINVOKE.FloatVector_LastIndexOf(swigCPtr, value);
-    return ret;
-  }
-
-  public bool Remove(float value) {
-    bool ret = AssimpPINVOKE.FloatVector_Remove(swigCPtr, value);
-    return ret;
-  }
-
-}

port/Assimp.NET/Assimp.NET_CS/Importer.cs

@@ -1,206 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class Importer : IDisposable {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal Importer(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(Importer obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~Importer() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_Importer(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public Importer() : this(AssimpPINVOKE.new_Importer__SWIG_0(), true) {
-  }
-
-  public Importer(Importer other) : this(AssimpPINVOKE.new_Importer__SWIG_1(Importer.getCPtr(other)), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public int GetPropertyInteger(string szName, int iErrorReturn) {
-    int ret = AssimpPINVOKE.Importer_GetPropertyInteger__SWIG_0(swigCPtr, szName, iErrorReturn);
-    return ret;
-  }
-
-  public int GetPropertyInteger(string szName) {
-    int ret = AssimpPINVOKE.Importer_GetPropertyInteger__SWIG_1(swigCPtr, szName);
-    return ret;
-  }
-
-  public bool GetPropertyBool(string szName, bool bErrorReturn) {
-    bool ret = AssimpPINVOKE.Importer_GetPropertyBool__SWIG_0(swigCPtr, szName, bErrorReturn);
-    return ret;
-  }
-
-  public bool GetPropertyBool(string szName) {
-    bool ret = AssimpPINVOKE.Importer_GetPropertyBool__SWIG_1(swigCPtr, szName);
-    return ret;
-  }
-
-  public float GetPropertyFloat(string szName, float fErrorReturn) {
-    float ret = AssimpPINVOKE.Importer_GetPropertyFloat__SWIG_0(swigCPtr, szName, fErrorReturn);
-    return ret;
-  }
-
-  public float GetPropertyFloat(string szName) {
-    float ret = AssimpPINVOKE.Importer_GetPropertyFloat__SWIG_1(swigCPtr, szName);
-    return ret;
-  }
-
-  public string GetPropertyString(string szName, string sErrorReturn) {
-    string ret = AssimpPINVOKE.Importer_GetPropertyString__SWIG_0(swigCPtr, szName, sErrorReturn);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public string GetPropertyString(string szName) {
-    string ret = AssimpPINVOKE.Importer_GetPropertyString__SWIG_1(swigCPtr, szName);
-    return ret;
-  }
-
-  public bool IsDefaultIOHandler() {
-    bool ret = AssimpPINVOKE.Importer_IsDefaultIOHandler(swigCPtr);
-    return ret;
-  }
-
-  public void SetProgressHandler(ProgressHandler pHandler) {
-    AssimpPINVOKE.Importer_SetProgressHandler(swigCPtr, ProgressHandler.getCPtr(pHandler));
-  }
-
-  public ProgressHandler GetProgressHandler() {
-    IntPtr cPtr = AssimpPINVOKE.Importer_GetProgressHandler(swigCPtr);
-    ProgressHandler ret = (cPtr == IntPtr.Zero) ? null : new ProgressHandler(cPtr, false);
-    return ret;
-  }
-
-  public bool IsDefaultProgressHandler() {
-    bool ret = AssimpPINVOKE.Importer_IsDefaultProgressHandler(swigCPtr);
-    return ret;
-  }
-
-  public bool ValidateFlags(aiPostProcessSteps pFlags) {
-    bool ret = AssimpPINVOKE.Importer_ValidateFlags(swigCPtr, (uint)pFlags);
-    return ret;
-  }
-
-  public aiScene ReadFile(string pFile, aiPostProcessSteps pFlags) {
-    IntPtr cPtr = AssimpPINVOKE.Importer_ReadFile__SWIG_0(swigCPtr, pFile, (uint)pFlags);
-    aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false);
-    return ret;
-  }
-
-  public void FreeScene() {
-    AssimpPINVOKE.Importer_FreeScene(swigCPtr);
-  }
-
-  public string GetErrorString() {
-    string ret = AssimpPINVOKE.Importer_GetErrorString(swigCPtr);
-    return ret;
-  }
-
-  public aiScene GetScene() {
-    IntPtr cPtr = AssimpPINVOKE.Importer_GetScene(swigCPtr);
-    aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false);
-    return ret;
-  }
-
-  public aiScene GetOrphanedScene() {
-    IntPtr cPtr = AssimpPINVOKE.Importer_GetOrphanedScene(swigCPtr);
-    aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false);
-    return ret;
-  }
-
-  public bool IsExtensionSupported(string szExtension) {
-    bool ret = AssimpPINVOKE.Importer_IsExtensionSupported__SWIG_0(swigCPtr, szExtension);
-    return ret;
-  }
-
-  public void GetExtensionList(aiString szOut) {
-    AssimpPINVOKE.Importer_GetExtensionList__SWIG_0(swigCPtr, aiString.getCPtr(szOut));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void GetExtensionList(SWIGTYPE_p_std__string szOut) {
-    AssimpPINVOKE.Importer_GetExtensionList__SWIG_1(swigCPtr, SWIGTYPE_p_std__string.getCPtr(szOut));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public uint GetImporterCount() {
-    uint ret = AssimpPINVOKE.Importer_GetImporterCount(swigCPtr);
-    return ret;
-  }
-
-  public SWIGTYPE_p_aiImporterDesc GetImporterInfo(uint index) {
-    IntPtr cPtr = AssimpPINVOKE.Importer_GetImporterInfo(swigCPtr, index);
-    SWIGTYPE_p_aiImporterDesc ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_aiImporterDesc(cPtr, false);
-    return ret;
-  }
-
-  public SWIGTYPE_p_Assimp__BaseImporter GetImporter(uint index) {
-    IntPtr cPtr = AssimpPINVOKE.Importer_GetImporter__SWIG_0(swigCPtr, index);
-    SWIGTYPE_p_Assimp__BaseImporter ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_Assimp__BaseImporter(cPtr, false);
-    return ret;
-  }
-
-  public SWIGTYPE_p_Assimp__BaseImporter GetImporter(string szExtension) {
-    IntPtr cPtr = AssimpPINVOKE.Importer_GetImporter__SWIG_1(swigCPtr, szExtension);
-    SWIGTYPE_p_Assimp__BaseImporter ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_Assimp__BaseImporter(cPtr, false);
-    return ret;
-  }
-
-  public uint GetImporterIndex(string szExtension) {
-    uint ret = AssimpPINVOKE.Importer_GetImporterIndex(swigCPtr, szExtension);
-    return ret;
-  }
-
-  public void GetMemoryRequirements(aiMemoryInfo arg0) {
-    AssimpPINVOKE.Importer_GetMemoryRequirements(swigCPtr, aiMemoryInfo.getCPtr(arg0));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void SetExtraVerbose(bool bDo) {
-    AssimpPINVOKE.Importer_SetExtraVerbose(swigCPtr, bDo);
-  }
-
-  public SWIGTYPE_p_Assimp__ImporterPimpl Pimpl() {
-    IntPtr cPtr = AssimpPINVOKE.Importer_Pimpl__SWIG_0(swigCPtr);
-    SWIGTYPE_p_Assimp__ImporterPimpl ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_Assimp__ImporterPimpl(cPtr, false);
-    return ret;
-  }
-
-  public string GetExtensionList() {
-    string ret = AssimpPINVOKE.Importer_GetExtensionList__SWIG_2(swigCPtr);
-    return ret;
-  }
-
-}

port/Assimp.NET/Assimp.NET_CS/ProgressHandler.cs

@@ -1,53 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class ProgressHandler : IDisposable {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal ProgressHandler(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(ProgressHandler obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~ProgressHandler() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_ProgressHandler(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public virtual bool Update(float percentage) {
-    bool ret = AssimpPINVOKE.ProgressHandler_Update__SWIG_0(swigCPtr, percentage);
-    return ret;
-  }
-
-  public virtual bool Update() {
-    bool ret = AssimpPINVOKE.ProgressHandler_Update__SWIG_1(swigCPtr);
-    return ret;
-  }
-
-}

port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_Assimp__BaseImporter.cs

@@ -1,27 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class SWIGTYPE_p_Assimp__BaseImporter {
-  private HandleRef swigCPtr;
-
-  internal SWIGTYPE_p_Assimp__BaseImporter(IntPtr cPtr, bool futureUse) {
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  protected SWIGTYPE_p_Assimp__BaseImporter() {
-    swigCPtr = new HandleRef(null, IntPtr.Zero);
-  }
-
-  internal static HandleRef getCPtr(SWIGTYPE_p_Assimp__BaseImporter obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-}

port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_Assimp__ImporterPimpl.cs

@@ -1,27 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class SWIGTYPE_p_Assimp__ImporterPimpl {
-  private HandleRef swigCPtr;
-
-  internal SWIGTYPE_p_Assimp__ImporterPimpl(IntPtr cPtr, bool futureUse) {
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  protected SWIGTYPE_p_Assimp__ImporterPimpl() {
-    swigCPtr = new HandleRef(null, IntPtr.Zero);
-  }
-
-  internal static HandleRef getCPtr(SWIGTYPE_p_Assimp__ImporterPimpl obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-}

port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_aiImporterDesc.cs

@@ -1,27 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class SWIGTYPE_p_aiImporterDesc {
-  private HandleRef swigCPtr;
-
-  internal SWIGTYPE_p_aiImporterDesc(IntPtr cPtr, bool futureUse) {
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  protected SWIGTYPE_p_aiImporterDesc() {
-    swigCPtr = new HandleRef(null, IntPtr.Zero);
-  }
-
-  internal static HandleRef getCPtr(SWIGTYPE_p_aiImporterDesc obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-}

port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_float.cs

@@ -1,27 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class SWIGTYPE_p_float {
-  private HandleRef swigCPtr;
-
-  internal SWIGTYPE_p_float(IntPtr cPtr, bool futureUse) {
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  protected SWIGTYPE_p_float() {
-    swigCPtr = new HandleRef(null, IntPtr.Zero);
-  }
-
-  internal static HandleRef getCPtr(SWIGTYPE_p_float obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-}

port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_std__string.cs

@@ -1,27 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class SWIGTYPE_p_std__string {
-  private HandleRef swigCPtr;
-
-  internal SWIGTYPE_p_std__string(IntPtr cPtr, bool futureUse) {
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  protected SWIGTYPE_p_std__string() {
-    swigCPtr = new HandleRef(null, IntPtr.Zero);
-  }
-
-  internal static HandleRef getCPtr(SWIGTYPE_p_std__string obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-}

port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_void.cs

@@ -1,27 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class SWIGTYPE_p_void {
-  private HandleRef swigCPtr;
-
-  internal SWIGTYPE_p_void(IntPtr cPtr, bool futureUse) {
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  protected SWIGTYPE_p_void() {
-    swigCPtr = new HandleRef(null, IntPtr.Zero);
-  }
-
-  internal static HandleRef getCPtr(SWIGTYPE_p_void obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-}

port/Assimp.NET/Assimp.NET_CS/UintVector.cs

@@ -1,346 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class UintVector : IDisposable, System.Collections.IEnumerable
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IList<uint>
-#endif
- {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal UintVector(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(UintVector obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~UintVector() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_UintVector(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public UintVector(System.Collections.ICollection c) : this() {
-    if (c == null)
-      throw new ArgumentNullException("c");
-    foreach (uint element in c) {
-      this.Add(element);
-    }
-  }
-
-  public bool IsFixedSize {
-    get {
-      return false;
-    }
-  }
-
-  public bool IsReadOnly {
-    get {
-      return false;
-    }
-  }
-
-  public uint this[int index]  {
-    get {
-      return getitem(index);
-    }
-    set {
-      setitem(index, value);
-    }
-  }
-
-  public int Capacity {
-    get {
-      return (int)capacity();
-    }
-    set {
-      if (value < size())
-        throw new ArgumentOutOfRangeException("Capacity");
-      reserve((uint)value);
-    }
-  }
-
-  public int Count {
-    get {
-      return (int)size();
-    }
-  }
-
-  public bool IsSynchronized {
-    get {
-      return false;
-    }
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(System.Array array)
-#else
-  public void CopyTo(uint[] array)
-#endif
-  {
-    CopyTo(0, array, 0, this.Count);
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(System.Array array, int arrayIndex)
-#else
-  public void CopyTo(uint[] array, int arrayIndex)
-#endif
-  {
-    CopyTo(0, array, arrayIndex, this.Count);
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(int index, System.Array array, int arrayIndex, int count)
-#else
-  public void CopyTo(int index, uint[] array, int arrayIndex, int count)
-#endif
-  {
-    if (array == null)
-      throw new ArgumentNullException("array");
-    if (index < 0)
-      throw new ArgumentOutOfRangeException("index", "Value is less than zero");
-    if (arrayIndex < 0)
-      throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
-    if (count < 0)
-      throw new ArgumentOutOfRangeException("count", "Value is less than zero");
-    if (array.Rank > 1)
-      throw new ArgumentException("Multi dimensional array.", "array");
-    if (index+count > this.Count || arrayIndex+count > array.Length)
-      throw new ArgumentException("Number of elements to copy is too large.");
-    for (int i=0; i<count; i++)
-      array.SetValue(getitemcopy(index+i), arrayIndex+i);
-  }
-
-#if !SWIG_DOTNET_1
-  System.Collections.Generic.IEnumerator<uint> System.Collections.Generic.IEnumerable<uint>.GetEnumerator() {
-    return new UintVectorEnumerator(this);
-  }
-#endif
-
-  System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
-    return new UintVectorEnumerator(this);
-  }
-
-  public UintVectorEnumerator GetEnumerator() {
-    return new UintVectorEnumerator(this);
-  }
-
-  // Type-safe enumerator
-  /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
-  /// whenever the collection is modified. This has been done for changes in the size of the
-  /// collection but not when one of the elements of the collection is modified as it is a bit
-  /// tricky to detect unmanaged code that modifies the collection under our feet.
-  public sealed class UintVectorEnumerator : System.Collections.IEnumerator
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IEnumerator<uint>
-#endif
-  {
-    private UintVector collectionRef;
-    private int currentIndex;
-    private object currentObject;
-    private int currentSize;
-
-    public UintVectorEnumerator(UintVector collection) {
-      collectionRef = collection;
-      currentIndex = -1;
-      currentObject = null;
-      currentSize = collectionRef.Count;
-    }
-
-    // Type-safe iterator Current
-    public uint Current {
-      get {
-        if (currentIndex == -1)
-          throw new InvalidOperationException("Enumeration not started.");
-        if (currentIndex > currentSize - 1)
-          throw new InvalidOperationException("Enumeration finished.");
-        if (currentObject == null)
-          throw new InvalidOperationException("Collection modified.");
-        return (uint)currentObject;
-      }
-    }
-
-    // Type-unsafe IEnumerator.Current
-    object System.Collections.IEnumerator.Current {
-      get {
-        return Current;
-      }
-    }
-
-    public bool MoveNext() {
-      int size = collectionRef.Count;
-      bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
-      if (moveOkay) {
-        currentIndex++;
-        currentObject = collectionRef[currentIndex];
-      } else {
-        currentObject = null;
-      }
-      return moveOkay;
-    }
-
-    public void Reset() {
-      currentIndex = -1;
-      currentObject = null;
-      if (collectionRef.Count != currentSize) {
-        throw new InvalidOperationException("Collection modified.");
-      }
-    }
-
-#if !SWIG_DOTNET_1
-    public void Dispose() {
-        currentIndex = -1;
-        currentObject = null;
-    }
-#endif
-  }
-
-  public void Clear() {
-    AssimpPINVOKE.UintVector_Clear(swigCPtr);
-  }
-
-  public void Add(uint x) {
-    AssimpPINVOKE.UintVector_Add(swigCPtr, x);
-  }
-
-  private uint size() {
-    uint ret = AssimpPINVOKE.UintVector_size(swigCPtr);
-    return ret;
-  }
-
-  private uint capacity() {
-    uint ret = AssimpPINVOKE.UintVector_capacity(swigCPtr);
-    return ret;
-  }
-
-  private void reserve(uint n) {
-    AssimpPINVOKE.UintVector_reserve(swigCPtr, n);
-  }
-
-  public UintVector() : this(AssimpPINVOKE.new_UintVector__SWIG_0(), true) {
-  }
-
-  public UintVector(UintVector other) : this(AssimpPINVOKE.new_UintVector__SWIG_1(UintVector.getCPtr(other)), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public UintVector(int capacity) : this(AssimpPINVOKE.new_UintVector__SWIG_2(capacity), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  private uint getitemcopy(int index) {
-    uint ret = AssimpPINVOKE.UintVector_getitemcopy(swigCPtr, index);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private uint getitem(int index) {
-    uint ret = AssimpPINVOKE.UintVector_getitem(swigCPtr, index);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private void setitem(int index, uint val) {
-    AssimpPINVOKE.UintVector_setitem(swigCPtr, index, val);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void AddRange(UintVector values) {
-    AssimpPINVOKE.UintVector_AddRange(swigCPtr, UintVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public UintVector GetRange(int index, int count) {
-    IntPtr cPtr = AssimpPINVOKE.UintVector_GetRange(swigCPtr, index, count);
-    UintVector ret = (cPtr == IntPtr.Zero) ? null : new UintVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Insert(int index, uint x) {
-    AssimpPINVOKE.UintVector_Insert(swigCPtr, index, x);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void InsertRange(int index, UintVector values) {
-    AssimpPINVOKE.UintVector_InsertRange(swigCPtr, index, UintVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveAt(int index) {
-    AssimpPINVOKE.UintVector_RemoveAt(swigCPtr, index);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveRange(int index, int count) {
-    AssimpPINVOKE.UintVector_RemoveRange(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public static UintVector Repeat(uint value, int count) {
-    IntPtr cPtr = AssimpPINVOKE.UintVector_Repeat(value, count);
-    UintVector ret = (cPtr == IntPtr.Zero) ? null : new UintVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Reverse() {
-    AssimpPINVOKE.UintVector_Reverse__SWIG_0(swigCPtr);
-  }
-
-  public void Reverse(int index, int count) {
-    AssimpPINVOKE.UintVector_Reverse__SWIG_1(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void SetRange(int index, UintVector values) {
-    AssimpPINVOKE.UintVector_SetRange(swigCPtr, index, UintVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public bool Contains(uint value) {
-    bool ret = AssimpPINVOKE.UintVector_Contains(swigCPtr, value);
-    return ret;
-  }
-
-  public int IndexOf(uint value) {
-    int ret = AssimpPINVOKE.UintVector_IndexOf(swigCPtr, value);
-    return ret;
-  }
-
-  public int LastIndexOf(uint value) {
-    int ret = AssimpPINVOKE.UintVector_LastIndexOf(swigCPtr, value);
-    return ret;
-  }
-
-  public bool Remove(uint value) {
-    bool ret = AssimpPINVOKE.UintVector_Remove(swigCPtr, value);
-    return ret;
-  }
-
-}

port/Assimp.NET/Assimp.NET_CS/aiAnimBehaviour.cs

@@ -1,15 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-public enum aiAnimBehaviour {
-  aiAnimBehaviour_DEFAULT = 0x0,
-  aiAnimBehaviour_CONSTANT = 0x1,
-  aiAnimBehaviour_LINEAR = 0x2,
-  aiAnimBehaviour_REPEAT = 0x3
-}

port/Assimp.NET/Assimp.NET_CS/aiAnimMesh.cs

@@ -1,92 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class aiAnimMesh : IDisposable {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiAnimMesh(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiAnimMesh obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiAnimMesh() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_aiAnimMesh(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public aiVector3D mBitangents {
-    set {
-      AssimpPINVOKE.aiAnimMesh_mBitangents_set(swigCPtr, aiVector3D.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = AssimpPINVOKE.aiAnimMesh_mBitangents_get(swigCPtr);
-      aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public uint mNumVertices {
-    set {
-      AssimpPINVOKE.aiAnimMesh_mNumVertices_set(swigCPtr, value);
-    } 
-    get {
-      uint ret = AssimpPINVOKE.aiAnimMesh_mNumVertices_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public aiAnimMesh() : this(AssimpPINVOKE.new_aiAnimMesh(), true) {
-  }
-
-  public bool HasPositions() {
-    bool ret = AssimpPINVOKE.aiAnimMesh_HasPositions(swigCPtr);
-    return ret;
-  }
-
-  public bool HasNormals() {
-    bool ret = AssimpPINVOKE.aiAnimMesh_HasNormals(swigCPtr);
-    return ret;
-  }
-
-  public bool HasTangentsAndBitangents() {
-    bool ret = AssimpPINVOKE.aiAnimMesh_HasTangentsAndBitangents(swigCPtr);
-    return ret;
-  }
-
-  public bool HasVertexColors(uint pIndex) {
-    bool ret = AssimpPINVOKE.aiAnimMesh_HasVertexColors(swigCPtr, pIndex);
-    return ret;
-  }
-
-  public bool HasTextureCoords(uint pIndex) {
-    bool ret = AssimpPINVOKE.aiAnimMesh_HasTextureCoords(swigCPtr, pIndex);
-    return ret;
-  }
-
-}

port/Assimp.NET/Assimp.NET_CS/aiAnimMeshVector.cs

@@ -1,348 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class aiAnimMeshVector : IDisposable, System.Collections.IEnumerable
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IList<aiAnimMesh>
-#endif
- {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiAnimMeshVector(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiAnimMeshVector obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiAnimMeshVector() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_aiAnimMeshVector(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public aiAnimMeshVector(System.Collections.ICollection c) : this() {
-    if (c == null)
-      throw new ArgumentNullException("c");
-    foreach (aiAnimMesh element in c) {
-      this.Add(element);
-    }
-  }
-
-  public bool IsFixedSize {
-    get {
-      return false;
-    }
-  }
-
-  public bool IsReadOnly {
-    get {
-      return false;
-    }
-  }
-
-  public aiAnimMesh this[int index]  {
-    get {
-      return getitem(index);
-    }
-    set {
-      setitem(index, value);
-    }
-  }
-
-  public int Capacity {
-    get {
-      return (int)capacity();
-    }
-    set {
-      if (value < size())
-        throw new ArgumentOutOfRangeException("Capacity");
-      reserve((uint)value);
-    }
-  }
-
-  public int Count {
-    get {
-      return (int)size();
-    }
-  }
-
-  public bool IsSynchronized {
-    get {
-      return false;
-    }
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(System.Array array)
-#else
-  public void CopyTo(aiAnimMesh[] array)
-#endif
-  {
-    CopyTo(0, array, 0, this.Count);
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(System.Array array, int arrayIndex)
-#else
-  public void CopyTo(aiAnimMesh[] array, int arrayIndex)
-#endif
-  {
-    CopyTo(0, array, arrayIndex, this.Count);
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(int index, System.Array array, int arrayIndex, int count)
-#else
-  public void CopyTo(int index, aiAnimMesh[] array, int arrayIndex, int count)
-#endif
-  {
-    if (array == null)
-      throw new ArgumentNullException("array");
-    if (index < 0)
-      throw new ArgumentOutOfRangeException("index", "Value is less than zero");
-    if (arrayIndex < 0)
-      throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
-    if (count < 0)
-      throw new ArgumentOutOfRangeException("count", "Value is less than zero");
-    if (array.Rank > 1)
-      throw new ArgumentException("Multi dimensional array.", "array");
-    if (index+count > this.Count || arrayIndex+count > array.Length)
-      throw new ArgumentException("Number of elements to copy is too large.");
-    for (int i=0; i<count; i++)
-      array.SetValue(getitemcopy(index+i), arrayIndex+i);
-  }
-
-#if !SWIG_DOTNET_1
-  System.Collections.Generic.IEnumerator<aiAnimMesh> System.Collections.Generic.IEnumerable<aiAnimMesh>.GetEnumerator() {
-    return new aiAnimMeshVectorEnumerator(this);
-  }
-#endif
-
-  System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
-    return new aiAnimMeshVectorEnumerator(this);
-  }
-
-  public aiAnimMeshVectorEnumerator GetEnumerator() {
-    return new aiAnimMeshVectorEnumerator(this);
-  }
-
-  // Type-safe enumerator
-  /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
-  /// whenever the collection is modified. This has been done for changes in the size of the
-  /// collection but not when one of the elements of the collection is modified as it is a bit
-  /// tricky to detect unmanaged code that modifies the collection under our feet.
-  public sealed class aiAnimMeshVectorEnumerator : System.Collections.IEnumerator
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IEnumerator<aiAnimMesh>
-#endif
-  {
-    private aiAnimMeshVector collectionRef;
-    private int currentIndex;
-    private object currentObject;
-    private int currentSize;
-
-    public aiAnimMeshVectorEnumerator(aiAnimMeshVector collection) {
-      collectionRef = collection;
-      currentIndex = -1;
-      currentObject = null;
-      currentSize = collectionRef.Count;
-    }
-
-    // Type-safe iterator Current
-    public aiAnimMesh Current {
-      get {
-        if (currentIndex == -1)
-          throw new InvalidOperationException("Enumeration not started.");
-        if (currentIndex > currentSize - 1)
-          throw new InvalidOperationException("Enumeration finished.");
-        if (currentObject == null)
-          throw new InvalidOperationException("Collection modified.");
-        return (aiAnimMesh)currentObject;
-      }
-    }
-
-    // Type-unsafe IEnumerator.Current
-    object System.Collections.IEnumerator.Current {
-      get {
-        return Current;
-      }
-    }
-
-    public bool MoveNext() {
-      int size = collectionRef.Count;
-      bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
-      if (moveOkay) {
-        currentIndex++;
-        currentObject = collectionRef[currentIndex];
-      } else {
-        currentObject = null;
-      }
-      return moveOkay;
-    }
-
-    public void Reset() {
-      currentIndex = -1;
-      currentObject = null;
-      if (collectionRef.Count != currentSize) {
-        throw new InvalidOperationException("Collection modified.");
-      }
-    }
-
-#if !SWIG_DOTNET_1
-    public void Dispose() {
-        currentIndex = -1;
-        currentObject = null;
-    }
-#endif
-  }
-
-  public void Clear() {
-    AssimpPINVOKE.aiAnimMeshVector_Clear(swigCPtr);
-  }
-
-  public void Add(aiAnimMesh x) {
-    AssimpPINVOKE.aiAnimMeshVector_Add(swigCPtr, aiAnimMesh.getCPtr(x));
-  }
-
-  private uint size() {
-    uint ret = AssimpPINVOKE.aiAnimMeshVector_size(swigCPtr);
-    return ret;
-  }
-
-  private uint capacity() {
-    uint ret = AssimpPINVOKE.aiAnimMeshVector_capacity(swigCPtr);
-    return ret;
-  }
-
-  private void reserve(uint n) {
-    AssimpPINVOKE.aiAnimMeshVector_reserve(swigCPtr, n);
-  }
-
-  public aiAnimMeshVector() : this(AssimpPINVOKE.new_aiAnimMeshVector__SWIG_0(), true) {
-  }
-
-  public aiAnimMeshVector(aiAnimMeshVector other) : this(AssimpPINVOKE.new_aiAnimMeshVector__SWIG_1(aiAnimMeshVector.getCPtr(other)), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiAnimMeshVector(int capacity) : this(AssimpPINVOKE.new_aiAnimMeshVector__SWIG_2(capacity), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  private aiAnimMesh getitemcopy(int index) {
-    IntPtr cPtr = AssimpPINVOKE.aiAnimMeshVector_getitemcopy(swigCPtr, index);
-    aiAnimMesh ret = (cPtr == IntPtr.Zero) ? null : new aiAnimMesh(cPtr, false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private aiAnimMesh getitem(int index) {
-    IntPtr cPtr = AssimpPINVOKE.aiAnimMeshVector_getitem(swigCPtr, index);
-    aiAnimMesh ret = (cPtr == IntPtr.Zero) ? null : new aiAnimMesh(cPtr, false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private void setitem(int index, aiAnimMesh val) {
-    AssimpPINVOKE.aiAnimMeshVector_setitem(swigCPtr, index, aiAnimMesh.getCPtr(val));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void AddRange(aiAnimMeshVector values) {
-    AssimpPINVOKE.aiAnimMeshVector_AddRange(swigCPtr, aiAnimMeshVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiAnimMeshVector GetRange(int index, int count) {
-    IntPtr cPtr = AssimpPINVOKE.aiAnimMeshVector_GetRange(swigCPtr, index, count);
-    aiAnimMeshVector ret = (cPtr == IntPtr.Zero) ? null : new aiAnimMeshVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Insert(int index, aiAnimMesh x) {
-    AssimpPINVOKE.aiAnimMeshVector_Insert(swigCPtr, index, aiAnimMesh.getCPtr(x));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void InsertRange(int index, aiAnimMeshVector values) {
-    AssimpPINVOKE.aiAnimMeshVector_InsertRange(swigCPtr, index, aiAnimMeshVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveAt(int index) {
-    AssimpPINVOKE.aiAnimMeshVector_RemoveAt(swigCPtr, index);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveRange(int index, int count) {
-    AssimpPINVOKE.aiAnimMeshVector_RemoveRange(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public static aiAnimMeshVector Repeat(aiAnimMesh value, int count) {
-    IntPtr cPtr = AssimpPINVOKE.aiAnimMeshVector_Repeat(aiAnimMesh.getCPtr(value), count);
-    aiAnimMeshVector ret = (cPtr == IntPtr.Zero) ? null : new aiAnimMeshVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Reverse() {
-    AssimpPINVOKE.aiAnimMeshVector_Reverse__SWIG_0(swigCPtr);
-  }
-
-  public void Reverse(int index, int count) {
-    AssimpPINVOKE.aiAnimMeshVector_Reverse__SWIG_1(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void SetRange(int index, aiAnimMeshVector values) {
-    AssimpPINVOKE.aiAnimMeshVector_SetRange(swigCPtr, index, aiAnimMeshVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public bool Contains(aiAnimMesh value) {
-    bool ret = AssimpPINVOKE.aiAnimMeshVector_Contains(swigCPtr, aiAnimMesh.getCPtr(value));
-    return ret;
-  }
-
-  public int IndexOf(aiAnimMesh value) {
-    int ret = AssimpPINVOKE.aiAnimMeshVector_IndexOf(swigCPtr, aiAnimMesh.getCPtr(value));
-    return ret;
-  }
-
-  public int LastIndexOf(aiAnimMesh value) {
-    int ret = AssimpPINVOKE.aiAnimMeshVector_LastIndexOf(swigCPtr, aiAnimMesh.getCPtr(value));
-    return ret;
-  }
-
-  public bool Remove(aiAnimMesh value) {
-    bool ret = AssimpPINVOKE.aiAnimMeshVector_Remove(swigCPtr, aiAnimMesh.getCPtr(value));
-    return ret;
-  }
-
-}

port/Assimp.NET/Assimp.NET_CS/aiAnimation.cs

@@ -1,112 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class aiAnimation : IDisposable {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiAnimation(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiAnimation obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiAnimation() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_aiAnimation(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public aiNodeAnimVector mChannels { get { return GetmChannels(); } }
-  public aiMeshAnimVector mMeshChannels { get { return GetmMeshChannels(); } }
-
-  public aiString mName {
-    set {
-      AssimpPINVOKE.aiAnimation_mName_set(swigCPtr, aiString.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = AssimpPINVOKE.aiAnimation_mName_get(swigCPtr);
-      aiString ret = (cPtr == IntPtr.Zero) ? null : new aiString(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public double mDuration {
-    set {
-      AssimpPINVOKE.aiAnimation_mDuration_set(swigCPtr, value);
-    } 
-    get {
-      double ret = AssimpPINVOKE.aiAnimation_mDuration_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public double mTicksPerSecond {
-    set {
-      AssimpPINVOKE.aiAnimation_mTicksPerSecond_set(swigCPtr, value);
-    } 
-    get {
-      double ret = AssimpPINVOKE.aiAnimation_mTicksPerSecond_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public uint mNumChannels {
-    set {
-      AssimpPINVOKE.aiAnimation_mNumChannels_set(swigCPtr, value);
-    } 
-    get {
-      uint ret = AssimpPINVOKE.aiAnimation_mNumChannels_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public uint mNumMeshChannels {
-    set {
-      AssimpPINVOKE.aiAnimation_mNumMeshChannels_set(swigCPtr, value);
-    } 
-    get {
-      uint ret = AssimpPINVOKE.aiAnimation_mNumMeshChannels_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public aiAnimation() : this(AssimpPINVOKE.new_aiAnimation(), true) {
-  }
-
-  private aiNodeAnimVector GetmChannels() {
-    IntPtr cPtr = AssimpPINVOKE.aiAnimation_GetmChannels(swigCPtr);
-    aiNodeAnimVector ret = (cPtr == IntPtr.Zero) ? null : new aiNodeAnimVector(cPtr, true);
-    return ret;
-  }
-
-  private aiMeshAnimVector GetmMeshChannels() {
-    IntPtr cPtr = AssimpPINVOKE.aiAnimation_GetmMeshChannels(swigCPtr);
-    aiMeshAnimVector ret = (cPtr == IntPtr.Zero) ? null : new aiMeshAnimVector(cPtr, true);
-    return ret;
-  }
-
-}

port/Assimp.NET/Assimp.NET_CS/aiAnimationVector.cs

@@ -1,348 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class aiAnimationVector : IDisposable, System.Collections.IEnumerable
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IList<aiAnimation>
-#endif
- {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiAnimationVector(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiAnimationVector obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiAnimationVector() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_aiAnimationVector(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public aiAnimationVector(System.Collections.ICollection c) : this() {
-    if (c == null)
-      throw new ArgumentNullException("c");
-    foreach (aiAnimation element in c) {
-      this.Add(element);
-    }
-  }
-
-  public bool IsFixedSize {
-    get {
-      return false;
-    }
-  }
-
-  public bool IsReadOnly {
-    get {
-      return false;
-    }
-  }
-
-  public aiAnimation this[int index]  {
-    get {
-      return getitem(index);
-    }
-    set {
-      setitem(index, value);
-    }
-  }
-
-  public int Capacity {
-    get {
-      return (int)capacity();
-    }
-    set {
-      if (value < size())
-        throw new ArgumentOutOfRangeException("Capacity");
-      reserve((uint)value);
-    }
-  }
-
-  public int Count {
-    get {
-      return (int)size();
-    }
-  }
-
-  public bool IsSynchronized {
-    get {
-      return false;
-    }
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(System.Array array)
-#else
-  public void CopyTo(aiAnimation[] array)
-#endif
-  {
-    CopyTo(0, array, 0, this.Count);
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(System.Array array, int arrayIndex)
-#else
-  public void CopyTo(aiAnimation[] array, int arrayIndex)
-#endif
-  {
-    CopyTo(0, array, arrayIndex, this.Count);
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(int index, System.Array array, int arrayIndex, int count)
-#else
-  public void CopyTo(int index, aiAnimation[] array, int arrayIndex, int count)
-#endif
-  {
-    if (array == null)
-      throw new ArgumentNullException("array");
-    if (index < 0)
-      throw new ArgumentOutOfRangeException("index", "Value is less than zero");
-    if (arrayIndex < 0)
-      throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
-    if (count < 0)
-      throw new ArgumentOutOfRangeException("count", "Value is less than zero");
-    if (array.Rank > 1)
-      throw new ArgumentException("Multi dimensional array.", "array");
-    if (index+count > this.Count || arrayIndex+count > array.Length)
-      throw new ArgumentException("Number of elements to copy is too large.");
-    for (int i=0; i<count; i++)
-      array.SetValue(getitemcopy(index+i), arrayIndex+i);
-  }
-
-#if !SWIG_DOTNET_1
-  System.Collections.Generic.IEnumerator<aiAnimation> System.Collections.Generic.IEnumerable<aiAnimation>.GetEnumerator() {
-    return new aiAnimationVectorEnumerator(this);
-  }
-#endif
-
-  System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
-    return new aiAnimationVectorEnumerator(this);
-  }
-
-  public aiAnimationVectorEnumerator GetEnumerator() {
-    return new aiAnimationVectorEnumerator(this);
-  }
-
-  // Type-safe enumerator
-  /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
-  /// whenever the collection is modified. This has been done for changes in the size of the
-  /// collection but not when one of the elements of the collection is modified as it is a bit
-  /// tricky to detect unmanaged code that modifies the collection under our feet.
-  public sealed class aiAnimationVectorEnumerator : System.Collections.IEnumerator
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IEnumerator<aiAnimation>
-#endif
-  {
-    private aiAnimationVector collectionRef;
-    private int currentIndex;
-    private object currentObject;
-    private int currentSize;
-
-    public aiAnimationVectorEnumerator(aiAnimationVector collection) {
-      collectionRef = collection;
-      currentIndex = -1;
-      currentObject = null;
-      currentSize = collectionRef.Count;
-    }
-
-    // Type-safe iterator Current
-    public aiAnimation Current {
-      get {
-        if (currentIndex == -1)
-          throw new InvalidOperationException("Enumeration not started.");
-        if (currentIndex > currentSize - 1)
-          throw new InvalidOperationException("Enumeration finished.");
-        if (currentObject == null)
-          throw new InvalidOperationException("Collection modified.");
-        return (aiAnimation)currentObject;
-      }
-    }
-
-    // Type-unsafe IEnumerator.Current
-    object System.Collections.IEnumerator.Current {
-      get {
-        return Current;
-      }
-    }
-
-    public bool MoveNext() {
-      int size = collectionRef.Count;
-      bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
-      if (moveOkay) {
-        currentIndex++;
-        currentObject = collectionRef[currentIndex];
-      } else {
-        currentObject = null;
-      }
-      return moveOkay;
-    }
-
-    public void Reset() {
-      currentIndex = -1;
-      currentObject = null;
-      if (collectionRef.Count != currentSize) {
-        throw new InvalidOperationException("Collection modified.");
-      }
-    }
-
-#if !SWIG_DOTNET_1
-    public void Dispose() {
-        currentIndex = -1;
-        currentObject = null;
-    }
-#endif
-  }
-
-  public void Clear() {
-    AssimpPINVOKE.aiAnimationVector_Clear(swigCPtr);
-  }
-
-  public void Add(aiAnimation x) {
-    AssimpPINVOKE.aiAnimationVector_Add(swigCPtr, aiAnimation.getCPtr(x));
-  }
-
-  private uint size() {
-    uint ret = AssimpPINVOKE.aiAnimationVector_size(swigCPtr);
-    return ret;
-  }
-
-  private uint capacity() {
-    uint ret = AssimpPINVOKE.aiAnimationVector_capacity(swigCPtr);
-    return ret;
-  }
-
-  private void reserve(uint n) {
-    AssimpPINVOKE.aiAnimationVector_reserve(swigCPtr, n);
-  }
-
-  public aiAnimationVector() : this(AssimpPINVOKE.new_aiAnimationVector__SWIG_0(), true) {
-  }
-
-  public aiAnimationVector(aiAnimationVector other) : this(AssimpPINVOKE.new_aiAnimationVector__SWIG_1(aiAnimationVector.getCPtr(other)), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiAnimationVector(int capacity) : this(AssimpPINVOKE.new_aiAnimationVector__SWIG_2(capacity), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  private aiAnimation getitemcopy(int index) {
-    IntPtr cPtr = AssimpPINVOKE.aiAnimationVector_getitemcopy(swigCPtr, index);
-    aiAnimation ret = (cPtr == IntPtr.Zero) ? null : new aiAnimation(cPtr, false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private aiAnimation getitem(int index) {
-    IntPtr cPtr = AssimpPINVOKE.aiAnimationVector_getitem(swigCPtr, index);
-    aiAnimation ret = (cPtr == IntPtr.Zero) ? null : new aiAnimation(cPtr, false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private void setitem(int index, aiAnimation val) {
-    AssimpPINVOKE.aiAnimationVector_setitem(swigCPtr, index, aiAnimation.getCPtr(val));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void AddRange(aiAnimationVector values) {
-    AssimpPINVOKE.aiAnimationVector_AddRange(swigCPtr, aiAnimationVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiAnimationVector GetRange(int index, int count) {
-    IntPtr cPtr = AssimpPINVOKE.aiAnimationVector_GetRange(swigCPtr, index, count);
-    aiAnimationVector ret = (cPtr == IntPtr.Zero) ? null : new aiAnimationVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Insert(int index, aiAnimation x) {
-    AssimpPINVOKE.aiAnimationVector_Insert(swigCPtr, index, aiAnimation.getCPtr(x));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void InsertRange(int index, aiAnimationVector values) {
-    AssimpPINVOKE.aiAnimationVector_InsertRange(swigCPtr, index, aiAnimationVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveAt(int index) {
-    AssimpPINVOKE.aiAnimationVector_RemoveAt(swigCPtr, index);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveRange(int index, int count) {
-    AssimpPINVOKE.aiAnimationVector_RemoveRange(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public static aiAnimationVector Repeat(aiAnimation value, int count) {
-    IntPtr cPtr = AssimpPINVOKE.aiAnimationVector_Repeat(aiAnimation.getCPtr(value), count);
-    aiAnimationVector ret = (cPtr == IntPtr.Zero) ? null : new aiAnimationVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Reverse() {
-    AssimpPINVOKE.aiAnimationVector_Reverse__SWIG_0(swigCPtr);
-  }
-
-  public void Reverse(int index, int count) {
-    AssimpPINVOKE.aiAnimationVector_Reverse__SWIG_1(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void SetRange(int index, aiAnimationVector values) {
-    AssimpPINVOKE.aiAnimationVector_SetRange(swigCPtr, index, aiAnimationVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public bool Contains(aiAnimation value) {
-    bool ret = AssimpPINVOKE.aiAnimationVector_Contains(swigCPtr, aiAnimation.getCPtr(value));
-    return ret;
-  }
-
-  public int IndexOf(aiAnimation value) {
-    int ret = AssimpPINVOKE.aiAnimationVector_IndexOf(swigCPtr, aiAnimation.getCPtr(value));
-    return ret;
-  }
-
-  public int LastIndexOf(aiAnimation value) {
-    int ret = AssimpPINVOKE.aiAnimationVector_LastIndexOf(swigCPtr, aiAnimation.getCPtr(value));
-    return ret;
-  }
-
-  public bool Remove(aiAnimation value) {
-    bool ret = AssimpPINVOKE.aiAnimationVector_Remove(swigCPtr, aiAnimation.getCPtr(value));
-    return ret;
-  }
-
-}

port/Assimp.NET/Assimp.NET_CS/aiBlendMode.cs

@@ -1,13 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-public enum aiBlendMode {
-  aiBlendMode_Default = 0x0,
-  aiBlendMode_Additive = 0x1
-}

port/Assimp.NET/Assimp.NET_CS/aiBone.cs

@@ -1,88 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class aiBone : IDisposable {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiBone(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiBone obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiBone() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_aiBone(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public aiString mName {
-    set {
-      AssimpPINVOKE.aiBone_mName_set(swigCPtr, aiString.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = AssimpPINVOKE.aiBone_mName_get(swigCPtr);
-      aiString ret = (cPtr == IntPtr.Zero) ? null : new aiString(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public uint mNumWeights {
-    set {
-      AssimpPINVOKE.aiBone_mNumWeights_set(swigCPtr, value);
-    } 
-    get {
-      uint ret = AssimpPINVOKE.aiBone_mNumWeights_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public aiMatrix4x4 mOffsetMatrix {
-    set {
-      AssimpPINVOKE.aiBone_mOffsetMatrix_set(swigCPtr, aiMatrix4x4.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = AssimpPINVOKE.aiBone_mOffsetMatrix_get(swigCPtr);
-      aiMatrix4x4 ret = (cPtr == IntPtr.Zero) ? null : new aiMatrix4x4(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public aiBone() : this(AssimpPINVOKE.new_aiBone__SWIG_0(), true) {
-  }
-
-  public aiBone(aiBone other) : this(AssimpPINVOKE.new_aiBone__SWIG_1(aiBone.getCPtr(other)), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  private aiVertexWeightVector GetmWeights() {
-    IntPtr cPtr = AssimpPINVOKE.aiBone_GetmWeights(swigCPtr);
-    aiVertexWeightVector ret = (cPtr == IntPtr.Zero) ? null : new aiVertexWeightVector(cPtr, true);
-    return ret;
-  }
-
-}

port/Assimp.NET/Assimp.NET_CS/aiBoneVector.cs

@@ -1,348 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class aiBoneVector : IDisposable, System.Collections.IEnumerable
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IList<aiBone>
-#endif
- {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiBoneVector(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiBoneVector obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiBoneVector() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_aiBoneVector(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public aiBoneVector(System.Collections.ICollection c) : this() {
-    if (c == null)
-      throw new ArgumentNullException("c");
-    foreach (aiBone element in c) {
-      this.Add(element);
-    }
-  }
-
-  public bool IsFixedSize {
-    get {
-      return false;
-    }
-  }
-
-  public bool IsReadOnly {
-    get {
-      return false;
-    }
-  }
-
-  public aiBone this[int index]  {
-    get {
-      return getitem(index);
-    }
-    set {
-      setitem(index, value);
-    }
-  }
-
-  public int Capacity {
-    get {
-      return (int)capacity();
-    }
-    set {
-      if (value < size())
-        throw new ArgumentOutOfRangeException("Capacity");
-      reserve((uint)value);
-    }
-  }
-
-  public int Count {
-    get {
-      return (int)size();
-    }
-  }
-
-  public bool IsSynchronized {
-    get {
-      return false;
-    }
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(System.Array array)
-#else
-  public void CopyTo(aiBone[] array)
-#endif
-  {
-    CopyTo(0, array, 0, this.Count);
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(System.Array array, int arrayIndex)
-#else
-  public void CopyTo(aiBone[] array, int arrayIndex)
-#endif
-  {
-    CopyTo(0, array, arrayIndex, this.Count);
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(int index, System.Array array, int arrayIndex, int count)
-#else
-  public void CopyTo(int index, aiBone[] array, int arrayIndex, int count)
-#endif
-  {
-    if (array == null)
-      throw new ArgumentNullException("array");
-    if (index < 0)
-      throw new ArgumentOutOfRangeException("index", "Value is less than zero");
-    if (arrayIndex < 0)
-      throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
-    if (count < 0)
-      throw new ArgumentOutOfRangeException("count", "Value is less than zero");
-    if (array.Rank > 1)
-      throw new ArgumentException("Multi dimensional array.", "array");
-    if (index+count > this.Count || arrayIndex+count > array.Length)
-      throw new ArgumentException("Number of elements to copy is too large.");
-    for (int i=0; i<count; i++)
-      array.SetValue(getitemcopy(index+i), arrayIndex+i);
-  }
-
-#if !SWIG_DOTNET_1
-  System.Collections.Generic.IEnumerator<aiBone> System.Collections.Generic.IEnumerable<aiBone>.GetEnumerator() {
-    return new aiBoneVectorEnumerator(this);
-  }
-#endif
-
-  System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
-    return new aiBoneVectorEnumerator(this);
-  }
-
-  public aiBoneVectorEnumerator GetEnumerator() {
-    return new aiBoneVectorEnumerator(this);
-  }
-
-  // Type-safe enumerator
-  /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
-  /// whenever the collection is modified. This has been done for changes in the size of the
-  /// collection but not when one of the elements of the collection is modified as it is a bit
-  /// tricky to detect unmanaged code that modifies the collection under our feet.
-  public sealed class aiBoneVectorEnumerator : System.Collections.IEnumerator
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IEnumerator<aiBone>
-#endif
-  {
-    private aiBoneVector collectionRef;
-    private int currentIndex;
-    private object currentObject;
-    private int currentSize;
-
-    public aiBoneVectorEnumerator(aiBoneVector collection) {
-      collectionRef = collection;
-      currentIndex = -1;
-      currentObject = null;
-      currentSize = collectionRef.Count;
-    }
-
-    // Type-safe iterator Current
-    public aiBone Current {
-      get {
-        if (currentIndex == -1)
-          throw new InvalidOperationException("Enumeration not started.");
-        if (currentIndex > currentSize - 1)
-          throw new InvalidOperationException("Enumeration finished.");
-        if (currentObject == null)
-          throw new InvalidOperationException("Collection modified.");
-        return (aiBone)currentObject;
-      }
-    }
-
-    // Type-unsafe IEnumerator.Current
-    object System.Collections.IEnumerator.Current {
-      get {
-        return Current;
-      }
-    }
-
-    public bool MoveNext() {
-      int size = collectionRef.Count;
-      bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
-      if (moveOkay) {
-        currentIndex++;
-        currentObject = collectionRef[currentIndex];
-      } else {
-        currentObject = null;
-      }
-      return moveOkay;
-    }
-
-    public void Reset() {
-      currentIndex = -1;
-      currentObject = null;
-      if (collectionRef.Count != currentSize) {
-        throw new InvalidOperationException("Collection modified.");
-      }
-    }
-
-#if !SWIG_DOTNET_1
-    public void Dispose() {
-        currentIndex = -1;
-        currentObject = null;
-    }
-#endif
-  }
-
-  public void Clear() {
-    AssimpPINVOKE.aiBoneVector_Clear(swigCPtr);
-  }
-
-  public void Add(aiBone x) {
-    AssimpPINVOKE.aiBoneVector_Add(swigCPtr, aiBone.getCPtr(x));
-  }
-
-  private uint size() {
-    uint ret = AssimpPINVOKE.aiBoneVector_size(swigCPtr);
-    return ret;
-  }
-
-  private uint capacity() {
-    uint ret = AssimpPINVOKE.aiBoneVector_capacity(swigCPtr);
-    return ret;
-  }
-
-  private void reserve(uint n) {
-    AssimpPINVOKE.aiBoneVector_reserve(swigCPtr, n);
-  }
-
-  public aiBoneVector() : this(AssimpPINVOKE.new_aiBoneVector__SWIG_0(), true) {
-  }
-
-  public aiBoneVector(aiBoneVector other) : this(AssimpPINVOKE.new_aiBoneVector__SWIG_1(aiBoneVector.getCPtr(other)), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiBoneVector(int capacity) : this(AssimpPINVOKE.new_aiBoneVector__SWIG_2(capacity), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  private aiBone getitemcopy(int index) {
-    IntPtr cPtr = AssimpPINVOKE.aiBoneVector_getitemcopy(swigCPtr, index);
-    aiBone ret = (cPtr == IntPtr.Zero) ? null : new aiBone(cPtr, false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private aiBone getitem(int index) {
-    IntPtr cPtr = AssimpPINVOKE.aiBoneVector_getitem(swigCPtr, index);
-    aiBone ret = (cPtr == IntPtr.Zero) ? null : new aiBone(cPtr, false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private void setitem(int index, aiBone val) {
-    AssimpPINVOKE.aiBoneVector_setitem(swigCPtr, index, aiBone.getCPtr(val));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void AddRange(aiBoneVector values) {
-    AssimpPINVOKE.aiBoneVector_AddRange(swigCPtr, aiBoneVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiBoneVector GetRange(int index, int count) {
-    IntPtr cPtr = AssimpPINVOKE.aiBoneVector_GetRange(swigCPtr, index, count);
-    aiBoneVector ret = (cPtr == IntPtr.Zero) ? null : new aiBoneVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Insert(int index, aiBone x) {
-    AssimpPINVOKE.aiBoneVector_Insert(swigCPtr, index, aiBone.getCPtr(x));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void InsertRange(int index, aiBoneVector values) {
-    AssimpPINVOKE.aiBoneVector_InsertRange(swigCPtr, index, aiBoneVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveAt(int index) {
-    AssimpPINVOKE.aiBoneVector_RemoveAt(swigCPtr, index);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveRange(int index, int count) {
-    AssimpPINVOKE.aiBoneVector_RemoveRange(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public static aiBoneVector Repeat(aiBone value, int count) {
-    IntPtr cPtr = AssimpPINVOKE.aiBoneVector_Repeat(aiBone.getCPtr(value), count);
-    aiBoneVector ret = (cPtr == IntPtr.Zero) ? null : new aiBoneVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Reverse() {
-    AssimpPINVOKE.aiBoneVector_Reverse__SWIG_0(swigCPtr);
-  }
-
-  public void Reverse(int index, int count) {
-    AssimpPINVOKE.aiBoneVector_Reverse__SWIG_1(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void SetRange(int index, aiBoneVector values) {
-    AssimpPINVOKE.aiBoneVector_SetRange(swigCPtr, index, aiBoneVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public bool Contains(aiBone value) {
-    bool ret = AssimpPINVOKE.aiBoneVector_Contains(swigCPtr, aiBone.getCPtr(value));
-    return ret;
-  }
-
-  public int IndexOf(aiBone value) {
-    int ret = AssimpPINVOKE.aiBoneVector_IndexOf(swigCPtr, aiBone.getCPtr(value));
-    return ret;
-  }
-
-  public int LastIndexOf(aiBone value) {
-    int ret = AssimpPINVOKE.aiBoneVector_LastIndexOf(swigCPtr, aiBone.getCPtr(value));
-    return ret;
-  }
-
-  public bool Remove(aiBone value) {
-    bool ret = AssimpPINVOKE.aiBoneVector_Remove(swigCPtr, aiBone.getCPtr(value));
-    return ret;
-  }
-
-}

port/Assimp.NET/Assimp.NET_CS/aiCamera.cs

@@ -1,135 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class aiCamera : IDisposable {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiCamera(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiCamera obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiCamera() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_aiCamera(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public aiString mName {
-    set {
-      AssimpPINVOKE.aiCamera_mName_set(swigCPtr, aiString.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = AssimpPINVOKE.aiCamera_mName_get(swigCPtr);
-      aiString ret = (cPtr == IntPtr.Zero) ? null : new aiString(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public aiVector3D mPosition {
-    set {
-      AssimpPINVOKE.aiCamera_mPosition_set(swigCPtr, aiVector3D.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = AssimpPINVOKE.aiCamera_mPosition_get(swigCPtr);
-      aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public aiVector3D mUp {
-    set {
-      AssimpPINVOKE.aiCamera_mUp_set(swigCPtr, aiVector3D.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = AssimpPINVOKE.aiCamera_mUp_get(swigCPtr);
-      aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public aiVector3D mLookAt {
-    set {
-      AssimpPINVOKE.aiCamera_mLookAt_set(swigCPtr, aiVector3D.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = AssimpPINVOKE.aiCamera_mLookAt_get(swigCPtr);
-      aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public float mHorizontalFOV {
-    set {
-      AssimpPINVOKE.aiCamera_mHorizontalFOV_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiCamera_mHorizontalFOV_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public float mClipPlaneNear {
-    set {
-      AssimpPINVOKE.aiCamera_mClipPlaneNear_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiCamera_mClipPlaneNear_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public float mClipPlaneFar {
-    set {
-      AssimpPINVOKE.aiCamera_mClipPlaneFar_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiCamera_mClipPlaneFar_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public float mAspect {
-    set {
-      AssimpPINVOKE.aiCamera_mAspect_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiCamera_mAspect_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public aiCamera() : this(AssimpPINVOKE.new_aiCamera(), true) {
-  }
-
-  public void GetCameraMatrix(aiMatrix4x4 arg0) {
-    AssimpPINVOKE.aiCamera_GetCameraMatrix(swigCPtr, aiMatrix4x4.getCPtr(arg0));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-}

port/Assimp.NET/Assimp.NET_CS/aiCameraVector.cs

@@ -1,348 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
- *
- * Do not make changes to this file unless you know what you are doing--modify
- * the SWIG interface file instead.
- * ----------------------------------------------------------------------------- */
-
-
-using System;
-using System.Runtime.InteropServices;
-
-public class aiCameraVector : IDisposable, System.Collections.IEnumerable
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IList<aiCamera>
-#endif
- {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiCameraVector(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiCameraVector obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiCameraVector() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_aiCameraVector(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public aiCameraVector(System.Collections.ICollection c) : this() {
-    if (c == null)
-      throw new ArgumentNullException("c");
-    foreach (aiCamera element in c) {
-      this.Add(element);
-    }
-  }
-
-  public bool IsFixedSize {
-    get {
-      return false;
-    }
-  }
-
-  public bool IsReadOnly {
-    get {
-      return false;
-    }
-  }
-
-  public aiCamera this[int index]  {
-    get {
-      return getitem(index);
-    }
-    set {
-      setitem(index, value);
-    }
-  }
-
-  public int Capacity {
-    get {
-      return (int)capacity();
-    }
-    set {
-      if (value < size())
-        throw new ArgumentOutOfRangeException("Capacity");
-      reserve((uint)value);
-    }
-  }
-
-  public int Count {
-    get {
-      return (int)size();
-    }
-  }
-
-  public bool IsSynchronized {
-    get {
-      return false;
-    }
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(System.Array array)
-#else
-  public void CopyTo(aiCamera[] array)
-#endif
-  {
-    CopyTo(0, array, 0, this.Count);
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(System.Array array, int arrayIndex)
-#else
-  public void CopyTo(aiCamera[] array, int arrayIndex)
-#endif
-  {
-    CopyTo(0, array, arrayIndex, this.Count);
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(int index, System.Array array, int arrayIndex, int count)
-#else
-  public void CopyTo(int index, aiCamera[] array, int arrayIndex, int count)
-#endif
-  {
-    if (array == null)
-      throw new ArgumentNullException("array");
-    if (index < 0)
-      throw new ArgumentOutOfRangeException("index", "Value is less than zero");
-    if (arrayIndex < 0)
-      throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
-    if (count < 0)
-      throw new ArgumentOutOfRangeException("count", "Value is less than zero");
-    if (array.Rank > 1)
-      throw new ArgumentException("Multi dimensional array.", "array");
-    if (index+count > this.Count || arrayIndex+count > array.Length)
-      throw new ArgumentException("Number of elements to copy is too large.");
-    for (int i=0; i<count; i++)
-      array.SetValue(getitemcopy(index+i), arrayIndex+i);
-  }
-
-#if !SWIG_DOTNET_1
-  System.Collections.Generic.IEnumerator<aiCamera> System.Collections.Generic.IEnumerable<aiCamera>.GetEnumerator() {
-    return new aiCameraVectorEnumerator(this);
-  }
-#endif
-
-  System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
-    return new aiCameraVectorEnumerator(this);
-  }
-
-  public aiCameraVectorEnumerator GetEnumerator() {
-    return new aiCameraVectorEnumerator(this);
-  }
-
-  // Type-safe enumerator
-  /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
-  /// whenever the collection is modified. This has been done for changes in the size of the
-  /// collection but not when one of the elements of the collection is modified as it is a bit
-  /// tricky to detect unmanaged code that modifies the collection under our feet.
-  public sealed class aiCameraVectorEnumerator : System.Collections.IEnumerator
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IEnumerator<aiCamera>
-#endif
-  {
-    private aiCameraVector collectionRef;
-    private int currentIndex;
-    private object currentObject;
-    private int currentSize;
-
-    public aiCameraVectorEnumerator(aiCameraVector collection) {
-      collectionRef = collection;
-      currentIndex = -1;
-      currentObject = null;
-      currentSize = collectionRef.Count;
-    }
-
-    // Type-safe iterator Current
-    public aiCamera Current {
-      get {
-        if (currentIndex == -1)
-          throw new InvalidOperationException("Enumeration not started.");
-        if (currentIndex > currentSize - 1)
-          throw new InvalidOperationException("Enumeration finished.");
-        if (currentObject == null)
-          throw new InvalidOperationException("Collection modified.");
-        return (aiCamera)currentObject;
-      }
-    }
-
-    // Type-unsafe IEnumerator.Current
-    object System.Collections.IEnumerator.Current {
-      get {
-        return Current;
-      }
-    }
-
-    public bool MoveNext() {
-      int size = collectionRef.Count;
-      bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
-      if (moveOkay) {
-        currentIndex++;
-        currentObject = collectionRef[currentIndex];
-      } else {
-        currentObject = null;
-      }
-      return moveOkay;
-    }
-
-    public void Reset() {
-      currentIndex = -1;
-      currentObject = null;
-      if (collectionRef.Count != currentSize) {
-        throw new InvalidOperationException("Collection modified.");
-      }
-    }
-
-#if !SWIG_DOTNET_1
-    public void Dispose() {
-        currentIndex = -1;
-        currentObject = null;
-    }
-#endif
-  }
-
-  public void Clear() {
-    AssimpPINVOKE.aiCameraVector_Clear(swigCPtr);
-  }
-
-  public void Add(aiCamera x) {
-    AssimpPINVOKE.aiCameraVector_Add(swigCPtr, aiCamera.getCPtr(x));
-  }
-
-  private uint size() {
-    uint ret = AssimpPINVOKE.aiCameraVector_size(swigCPtr);
-    return ret;
-  }
-
-  private uint capacity() {
-    uint ret = AssimpPINVOKE.aiCameraVector_capacity(swigCPtr);
-    return ret;
-  }
-
-  private void reserve(uint n) {
-    AssimpPINVOKE.aiCameraVector_reserve(swigCPtr, n);
-  }
-
-  public aiCameraVector() : this(AssimpPINVOKE.new_aiCameraVector__SWIG_0(), true) {
-  }
-
-  public aiCameraVector(aiCameraVector other) : this(AssimpPINVOKE.new_aiCameraVector__SWIG_1(aiCameraVector.getCPtr(other)), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiCameraVector(int capacity) : this(AssimpPINVOKE.new_aiCameraVector__SWIG_2(capacity), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  private aiCamera getitemcopy(int index) {
-    IntPtr cPtr = AssimpPINVOKE.aiCameraVector_getitemcopy(swigCPtr, index);
-    aiCamera ret = (cPtr == IntPtr.Zero) ? null : new aiCamera(cPtr, false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private aiCamera getitem(int index) {
-    IntPtr cPtr = AssimpPINVOKE.aiCameraVector_getitem(swigCPtr, index);
-    aiCamera ret = (cPtr == IntPtr.Zero) ? null : new aiCamera(cPtr, false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private void setitem(int index, aiCamera val) {
-    AssimpPINVOKE.aiCameraVector_setitem(swigCPtr, index, aiCamera.getCPtr(val));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void AddRange(aiCameraVector values) {
-    AssimpPINVOKE.aiCameraVector_AddRange(swigCPtr, aiCameraVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiCameraVector GetRange(int index, int count) {
-    IntPtr cPtr = AssimpPINVOKE.aiCameraVector_GetRange(swigCPtr, index, count);
-    aiCameraVector ret = (cPtr == IntPtr.Zero) ? null : new aiCameraVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Insert(int index, aiCamera x) {
-    AssimpPINVOKE.aiCameraVector_Insert(swigCPtr, index, aiCamera.getCPtr(x));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void InsertRange(int index, aiCameraVector values) {
-    AssimpPINVOKE.aiCameraVector_InsertRange(swigCPtr, index, aiCameraVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveAt(int index) {
-    AssimpPINVOKE.aiCameraVector_RemoveAt(swigCPtr, index);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveRange(int index, int count) {
-    AssimpPINVOKE.aiCameraVector_RemoveRange(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public static aiCameraVector Repeat(aiCamera value, int count) {
-    IntPtr cPtr = AssimpPINVOKE.aiCameraVector_Repeat(aiCamera.getCPtr(value), count);
-    aiCameraVector ret = (cPtr == IntPtr.Zero) ? null : new aiCameraVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Reverse() {
-    AssimpPINVOKE.aiCameraVector_Reverse__SWIG_0(swigCPtr);
-  }
-
-  public void Reverse(int index, int count) {
-    AssimpPINVOKE.aiCameraVector_Reverse__SWIG_1(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void SetRange(int index, aiCameraVector values) {
-    AssimpPINVOKE.aiCameraVector_SetRange(swigCPtr, index, aiCameraVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public bool Contains(aiCamera value) {
-    bool ret = AssimpPINVOKE.aiCameraVector_Contains(swigCPtr, aiCamera.getCPtr(value));
-    return ret;
-  }
-
-  public int IndexOf(aiCamera value) {
-    int ret = AssimpPINVOKE.aiCameraVector_IndexOf(swigCPtr, aiCamera.getCPtr(value));
-    return ret;
-  }
-
-  public int LastIndexOf(aiCamera value) {
-    int ret = AssimpPINVOKE.aiCameraVector_LastIndexOf(swigCPtr, aiCamera.getCPtr(value));
-    return ret;
-  }
-
-  public bool Remove(aiCamera value) {
-    bool ret = AssimpPINVOKE.aiCameraVector_Remove(swigCPtr, aiCamera.getCPtr(value));
-    return ret;
-  }
-
-}