Merge remote-tracking branch 'official/master' into contrib

.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

@@ -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)

CREDITS

@@ -153,6 +153,8 @@ Ogre Binary format support
 Android JNI asset extraction support
 
 - Richard Steffen
-Contributed X File exporter
 Contributed ExportProperties interface
+Contributed X File exporter
+Contributed Step (stp) exporter
+
 

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.
-	
-	

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/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

@@ -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,12 @@ SET( XFile_SRCS
 	XFileExporter.h
 	XFileExporter.cpp
 )
-SOURCE_GROUP( XFile FILES ${XFile_SRCS})
+
+SET( Step_SRCS
+	StepExporter.h
+	StepExporter.cpp
+)
+SOURCE_GROUP( Step FILES ${Step_SRCS})
 
 SET( Exporter_SRCS
 	Exporter.cpp
@@ -674,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}
@@ -681,50 +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}
-	${Extra_SRCS}
-	${MS3D_SRCS}
-	${COB_SRCS}
-	${BLENDER_SRCS}
-	${NDO_SRCS}
-	${IFC_SRCS}
-	${XGL_SRCS}
-	${FBX_SRCS}
 
 	# Third-party libraries
 	${IrrXML_SRCS}
@@ -784,7 +734,7 @@ if( MSVC )
   else()
     set(MSVC_PREFIX "vc130")
   endif()
-  set(LIBRARY_SUFFIX "${ASSIMP_LIBRARY_SUFFIX}-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library" FORCE)
+  set(LIBRARY_SUFFIX "${ASSIMP_LIBRARY_SUFFIX}-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library")
 endif()
 
 SET_TARGET_PROPERTIES( assimp PROPERTIES

code/ColladaExporter.cpp

@@ -47,6 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "Bitmap.h"
 #include "fast_atof.h"
 #include "SceneCombiner.h"
+#include "DefaultIOSystem.h"
 #include "XMLTools.h"
 #include "../include/assimp/IOSystem.hpp"
 #include "../include/assimp/Exporter.hpp"
@@ -67,22 +68,8 @@ namespace Assimp
 // Worker function for exporting a scene to Collada. Prototyped and registered in Exporter.cpp
 void ExportSceneCollada(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
 {
-	std::string path = "";
+	std::string path = DefaultIOSystem::absolutePath(std::string(pFile));
-	std::string file = pFile;
+	std::string file = DefaultIOSystem::completeBaseName(std::string(pFile));
-
-	// We need to test both types of folder separators because pIOSystem->getOsSeparator() is not reliable.
-	// Moreover, the path given by some applications is not even consistent with the OS specific type of separator.
-	const char* end_path = std::max(strrchr(pFile, '\\'), strrchr(pFile, '/'));
-
-	if(end_path != NULL) {
-		path = std::string(pFile, end_path + 1 - pFile);
-		file = file.substr(end_path + 1 - pFile, file.npos);
-
-		std::size_t pos = file.find_last_of('.');
-		if(pos != file.npos) {
-			file = file.substr(0, pos);
-		}
-	}
 
 	// invoke the exporter 
 	ColladaExporter iDoTheExportThing( pScene, pIOSystem, path, file);
@@ -140,6 +127,8 @@ void ColladaExporter::WriteFile()
 	WriteTextures();
 	WriteHeader();
 
+	WriteCamerasLibrary();
+	WriteLightsLibrary();
 	WriteMaterials();
 	WriteGeometryLibrary();
 
@@ -178,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;
@@ -299,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)
@@ -438,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 )
@@ -860,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 )
 	{
@@ -867,7 +1064,6 @@ 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;
 	PushTag();
 	mOutput << startstr << "<bind_material>" << 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();
 
@@ -145,7 +162,10 @@ protected:
   {
     bool exist;
 	 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)
@@ -173,12 +174,13 @@ struct InputSemanticMapEntry
 {
 	InputSemanticMapEntry()
 		:	mSet(0)
+		,	mType(IT_Invalid)
 	{}
 
 	//! Index of set, optional
 	unsigned int mSet;
 
-	//! Name of referenced vertex input
+	//! Type of referenced vertex input
 	InputType mType;
 };
 
@@ -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/DefaultIOSystem.cpp

@@ -167,4 +167,31 @@ bool DefaultIOSystem::ComparePaths (const char* one, const char* second) const
 	return !ASSIMP_stricmp(temp1,temp2);
 }
 
+
+std::string DefaultIOSystem::fileName(std::string path)
+{
+	std::string ret = path;
+	std::size_t last = ret.find_last_of("\\/");
+	if (last != std::string::npos) ret = ret.substr(last + 1);
+	return ret;
+}
+
+
+std::string DefaultIOSystem::completeBaseName(std::string path)
+{
+	std::string ret = fileName(path);
+	std::size_t pos = ret.find_last_of('.');
+	if(pos != ret.npos) ret = ret.substr(0, pos);
+	return ret;
+}
+
+
+std::string DefaultIOSystem::absolutePath(std::string path)
+{
+	std::string ret = path;
+	std::size_t last = ret.find_last_of("\\/");
+	if (last != std::string::npos) ret = ret.substr(0, last);
+	return ret;
+}
+
 #undef PATHLIMIT

code/DefaultIOSystem.h

@@ -76,6 +76,21 @@ public:
 	// -------------------------------------------------------------------
 	/** Compare two paths */
 	bool ComparePaths (const char* one, const char* second) const;
+	
+	/** @brief get the file name of a full filepath
+	 * example: /tmp/archive.tar.gz -> archive.tar.gz
+	 */
+	static std::string fileName(std::string path);
+
+	/** @brief get the complete base name of a full filepath
+	 * example: /tmp/archive.tar.gz -> archive.tar
+	 */
+	static std::string completeBaseName(std::string path);
+
+	/** @brief get the path of a full filepath
+	 * example: /tmp/archive.tar.gz -> /tmp/
+	 */
+	static std::string absolutePath(std::string path);
 };
 
 } //!ns Assimp

code/Exporter.cpp

@@ -80,6 +80,7 @@ void GetPostProcessingStepInstanceList(std::vector< BaseProcess* >& out);
 // do not use const, because some exporter need to convert the scene temporary
 void ExportSceneCollada(const char*,IOSystem*, const aiScene*, const ExportProperties*);
 void ExportSceneXFile(const char*,IOSystem*, const aiScene*, const ExportProperties*);
+void ExportSceneStep(const char*,IOSystem*, const aiScene*, const ExportProperties*);
 void ExportSceneObj(const char*,IOSystem*, const aiScene*, const ExportProperties*);
 void ExportSceneSTL(const char*,IOSystem*, const aiScene*, const ExportProperties*);
 void ExportSceneSTLBinary(const char*,IOSystem*, const aiScene*, const ExportProperties*);
@@ -102,6 +103,10 @@ Exporter::ExportFormatEntry gExporters[] =
 		aiProcess_MakeLeftHanded | aiProcess_FlipWindingOrder | aiProcess_FlipUVs),
 #endif
 
+#ifndef ASSIMP_BUILD_NO_STEP_EXPORTER
+	Exporter::ExportFormatEntry( "stp", "Step Files", "stp", &ExportSceneStep, 0),
+#endif
+
 #ifndef ASSIMP_BUILD_NO_OBJ_EXPORTER
 	Exporter::ExportFormatEntry( "obj", "Wavefront OBJ format", "obj", &ExportSceneObj, 
 		aiProcess_GenSmoothNormals /*| aiProcess_PreTransformVertices */),

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/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/ObjFileMtlImporter.cpp

@@ -263,12 +263,17 @@ 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( "" );
 	if ( numToken == 1 ) {
 		name = AI_DEFAULT_MATERIAL_NAME;
 	} 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 );

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/OpenGEXImporter.cpp

@@ -45,7 +45,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <openddlparser/OpenDDLParser.h>
 #include <assimp/scene.h>
+#include <assimp/ai_assert.h>
 
+#include <algorithm>
 #include <vector>
 
 static const aiImporterDesc desc = {
@@ -79,6 +81,18 @@ namespace Grammar {
     static const char *IndexArrayType      = "IndexArray";
     static const char *MaterialType        = "Material";
     static const char *ColorType           = "Color";
+    static const std::string DiffuseColorToken = "diffuse";
+    static const std::string SpecularColorToken = "specular";
+    static const std::string EmissionColorToken = "emission";
+    
+    static const 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 {
@@ -178,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
 }
 
 //------------------------------------------------------------------------------------------------
@@ -210,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());
 }
 
 //------------------------------------------------------------------------------------------------
@@ -362,9 +376,9 @@ void OpenGEXImporter::handleMetricNode( DDLNode *node, aiScene *pScene ) {
 
     Property *prop( node->getProperties() );
     while( NULL != prop ) {
-        if( NULL != prop->m_id ) {
+        if( NULL != prop->m_key ) {
-            if( Value::ddl_string == prop->m_primData->m_type ) {
+            if( Value::ddl_string == prop->m_value->m_type ) {
-                std::string valName( (char*) prop->m_primData->m_data );
+                std::string valName( ( char* ) prop->m_value->m_data );
                 int type( Grammar::isValidMetricType( valName.c_str() ) );
                 if( Grammar::NoneType != type ) {
                     Value *val( node->getValue() );
@@ -401,7 +415,12 @@ void OpenGEXImporter::handleNameNode( DDLNode *node, aiScene *pScene ) {
         }
 
         const std::string name( val->getString() );
+        if( m_tokenType == Grammar::GeometryNodeToken ) {
             m_currentNode->mName.Set( name.c_str() );
+        } else if( m_tokenType == Grammar::MaterialToken ) {
+            
+        }
+
     }
 }
 
@@ -414,7 +433,7 @@ static void getRefNames( DDLNode *node, std::vector<std::string> &names ) {
         for( size_t i = 0; i < ref->m_numRefs; i++ )  {
             Name *currentName( ref->m_referencedName[ i ] );
             if( NULL != currentName && NULL != currentName->m_id ) {
-                const std::string name( currentName->m_id->m_buffer );
+                const std::string name( currentName->m_id->m_text.m_buffer );
                 if( !name.empty() ) {
                     names.push_back( name );
                 }
@@ -457,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 );
     
@@ -484,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 ];
+
 }
 
 //------------------------------------------------------------------------------------------------
@@ -529,10 +550,10 @@ static void propId2StdString( Property *prop, std::string &name, std::string &ke
         return;
     }
 
-    if( NULL != prop->m_id ) {
+    if( NULL != prop->m_key ) {
-        name = prop->m_id->m_buffer;
+        name = prop->m_key->m_text.m_buffer;
-        if( Value::ddl_string == prop->m_primData->m_type ) {
+        if( Value::ddl_string == prop->m_value->m_type ) {
-            key = prop->m_primData->getString();
+            key = prop->m_value->getString();
         }
     }
 }
@@ -653,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 ];
@@ -704,7 +724,7 @@ void OpenGEXImporter::handleIndexArrayNode( ODDLParser::DDLNode *node, aiScene *
         Value *next( vaList->m_dataList );
         for( size_t indices = 0; indices < current.mNumIndices; indices++ ) {
             const int idx = next->getInt32();
-            ai_assert( idx <= m_currentVertices.m_numVerts );
+            ai_assert( static_cast<size_t>( idx ) <= m_currentVertices.m_numVerts );
 
             aiVector3D &pos = ( m_currentVertices.m_vertices[ idx ] );
             aiVector3D &normal = ( m_currentVertices.m_normals[ idx ] );
@@ -724,30 +744,36 @@ void OpenGEXImporter::handleIndexArrayNode( ODDLParser::DDLNode *node, aiScene *
 }
 
 //------------------------------------------------------------------------------------------------
-static void getColorRGBA( aiColor3D *pColor, Value *data ) {
+static void getColorRGB( aiColor3D *pColor, DataArrayList *colList ) {
-    if( NULL == pColor || NULL == data ) {
+    if( NULL == pColor || NULL == colList ) {
         return;
     }
     
-    pColor->r = data->getFloat();
+    ai_assert( 3 == colList->m_numItems );
-    data = data->getNext();
+    Value *val( colList->m_dataList );
-    pColor->g = data->getFloat();
+    pColor->r = val->getFloat();
-    data = data->getNext();
+    val = val->getNext();
-    pColor->b = data->getFloat();
+    pColor->g = val->getFloat();
-    data = data->getNext();
+    val = val->getNext();
+    pColor->b = val->getFloat();
 }
 
 //------------------------------------------------------------------------------------------------
 enum ColorType {
     NoneColor = 0,
-    DiffuseColor
+    DiffuseColor,
+    SpecularColor,
+    EmissionColor
 };
 
 //------------------------------------------------------------------------------------------------
 static ColorType getColorType( Identifier *id ) {
-    const int res(strncmp("diffuse", id->m_buffer, id->m_len ) );
+    if( id->m_text == Grammar::DiffuseColorToken ) {
-    if( 0 == res ) {
         return DiffuseColor;
+    } else if( id->m_text == Grammar::SpecularColorToken ) {
+        return SpecularColor;
+    } else if( id->m_text == Grammar::EmissionColorToken ) {
+        return EmissionColor;
     }
 
     return NoneColor;
@@ -757,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 );
-
 }
 
 //------------------------------------------------------------------------------------------------
@@ -768,16 +793,64 @@ void OpenGEXImporter::handleColorNode( ODDLParser::DDLNode *node, aiScene *pScen
         return;
     }
 
-    Property *colorProp = node->getProperties();
+    Property *prop = node->findPropertyByName( "attrib" );
-    if( NULL != colorProp ) {
+    if( NULL != prop ) {
-        if( NULL != colorProp->m_id ) {
+        if( NULL != prop->m_value ) {
+            DataArrayList *colList( node->getDataArrayList() );
+            if( NULL == colList ) {
+                return;
+            }
+            aiColor3D col;
+            getColorRGB( &col, colList );
+            const ColorType colType( getColorType( prop->m_key ) );
+            if( DiffuseColor == colType ) {
+                m_currentMaterial->AddProperty( &col, 1, AI_MATKEY_COLOR_DIFFUSE );
+            } else if( SpecularColor == colType ) {
+                m_currentMaterial->AddProperty( &col, 1, AI_MATKEY_COLOR_SPECULAR );
+            } else if( EmissionColor == colType ) {
+                m_currentMaterial->AddProperty( &col, 1, AI_MATKEY_COLOR_EMISSIVE );
+            }
         }
     }
 }
 
 //------------------------------------------------------------------------------------------------
 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 );
+                }
+            }
+        }
+    }
 }
 
 //------------------------------------------------------------------------------------------------
@@ -785,6 +858,7 @@ void OpenGEXImporter::copyMeshes( aiScene *pScene ) {
     if( m_meshCache.empty() ) {
         return;
     }
+    
     pScene->mNumMeshes = m_meshCache.size();
     pScene->mMeshes = new aiMesh*[ pScene->mNumMeshes ];
     std::copy( m_meshCache.begin(), m_meshCache.end(), pScene->mMeshes );
@@ -828,13 +902,10 @@ void OpenGEXImporter::createNodeTree( aiScene *pScene ) {
     if( m_root->m_children.empty() ) {
         return;
     }
-    size_t i( 0 );
+
     pScene->mRootNode->mNumChildren = m_root->m_children.size();
-    pScene->mRootNode->mChildren = new C_STRUCT aiNode*[ pScene->mRootNode->mNumChildren ];
+    pScene->mRootNode->mChildren = new aiNode*[ pScene->mRootNode->mNumChildren ];
-    for( ChildInfo::NodeList::iterator it = m_root->m_children.begin(); it != m_root->m_children.end(); it++ ) {
+    std::copy( m_root->m_children.begin(), m_root->m_children.end(), pScene->mRootNode->mChildren );
-        pScene->mRootNode->mChildren[ i ] = *it;
-        i++;
-    }
 }
 
 //------------------------------------------------------------------------------------------------

code/OpenGEXImporter.h

@@ -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;

code/OptimizeMeshes.cpp

@@ -60,7 +60,8 @@ static const unsigned int DeadBeef = 0xdeadbeef;
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 OptimizeMeshesProcess::OptimizeMeshesProcess()
-: pts (false)
+    : mScene()
+    , pts(false)
     , max_verts( NotSet )
     , max_faces( NotSet ) {
     // empty

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/ProcessHelper.cpp

@@ -94,6 +94,26 @@ void FindMeshCenter (aiMesh* mesh, aiVector3D& out, aiVector3D& min, aiVector3D&
 	out = min + (max-min)*0.5f;
 }
 
+// -------------------------------------------------------------------------------
+void FindSceneCenter (aiScene* scene, aiVector3D& out, aiVector3D& min, aiVector3D& max)
+{
+	if (scene->mNumMeshes == 0) return;
+	FindMeshCenter(scene->mMeshes[0], out, min, max);
+	for (unsigned int i = 1; i < scene->mNumMeshes; ++i)
+	{
+		aiVector3D tout, tmin, tmax;
+		FindMeshCenter(scene->mMeshes[i], tout, tmin, tmax);
+		if (min[0] > tmin[0]) min[0] = tmin[0];
+		if (min[1] > tmin[1]) min[1] = tmin[1];
+		if (min[2] > tmin[2]) min[2] = tmin[2];
+		if (max[0] < tmax[0]) max[0] = tmax[0];
+		if (max[1] < tmax[1]) max[1] = tmax[1];
+		if (max[2] < tmax[2]) max[2] = tmax[2];
+	}
+	out = min + (max-min)*0.5f;
+}
+
+
 // -------------------------------------------------------------------------------
 void FindMeshCenterTransformed (aiMesh* mesh, aiVector3D& out, aiVector3D& min,
 	aiVector3D& max, const aiMatrix4x4& m)

code/ProcessHelper.h

@@ -265,6 +265,16 @@ void FindAABBTransformed (const aiMesh* mesh, aiVector3D& min, aiVector3D& max,
  *  @param[out] out Center point */
 void FindMeshCenter (aiMesh* mesh, aiVector3D& out, aiVector3D& min, aiVector3D& max);
 
+// -------------------------------------------------------------------------------
+/** @brief Helper function to determine the 'real' center of a scene
+ *
+ *  That is the center of its axis-aligned bounding box.
+ *  @param scene Input scene
+ *  @param[out] min Minimum vertex of the scene
+ *  @param[out] max maximum vertex of the scene
+ *  @param[out] out Center point */
+void FindSceneCenter (aiScene* scene, aiVector3D& out, aiVector3D& min, aiVector3D& max);
+
 
 // -------------------------------------------------------------------------------
 // Helper function to determine the 'real' center of a mesh after applying a given transform

code/RemoveVCProcess.cpp

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

code/STEPFileEncoding.cpp

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

code/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

@@ -0,0 +1,366 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2015, assimp team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, 
+with or without modification, are permitted provided that the 
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+@author: Richard Steffen, 2015
+----------------------------------------------------------------------
+*/
+
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_STEP_EXPORTER
+#include "StepExporter.h"
+#include "ConvertToLHProcess.h"
+#include "Bitmap.h"
+#include "BaseImporter.h"
+#include "fast_atof.h"
+#include "SceneCombiner.h" 
+#include "DefaultIOSystem.h"
+#include <iostream>
+#include <ctime>
+#include <set>
+#include <map>
+#include <list>
+#include <boost/scoped_ptr.hpp>
+#include "Exceptional.h"
+#include "../include/assimp/IOSystem.hpp"
+#include "../include/assimp/scene.h"
+#include "../include/assimp/light.h"
+
+//
+#if _MSC_VER > 1500 || (defined __GNUC___)
+#	define ASSIMP_STEP_USE_UNORDERED_MULTIMAP
+#	else
+#	define step_unordered_map map
+#	define step_unordered_multimap multimap
+#endif
+
+#ifdef ASSIMP_STEP_USE_UNORDERED_MULTIMAP
+#	include <unordered_map>
+#	if _MSC_VER > 1600
+#		define step_unordered_map unordered_map
+#		define step_unordered_multimap unordered_multimap
+#	else
+#		define step_unordered_map tr1::unordered_map
+#		define step_unordered_multimap tr1::unordered_multimap
+#	endif
+#endif
+
+typedef std::step_unordered_map<aiVector3D*, int> VectorIndexUMap;
+
+/* Tested with Step viewer v4 from www.ida-step.net */
+
+using namespace Assimp;
+
+namespace Assimp
+{
+
+// ------------------------------------------------------------------------------------------------
+// Worker function for exporting a scene to Collada. Prototyped and registered in Exporter.cpp
+void ExportSceneStep(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
+{
+	std::string path = DefaultIOSystem::absolutePath(std::string(pFile));
+	std::string file = DefaultIOSystem::completeBaseName(std::string(pFile));	
+
+	// create/copy Properties
+	ExportProperties props(*pProperties);
+
+	// invoke the exporter 
+	StepExporter iDoTheExportThing( pScene, pIOSystem, path, file, &props);
+
+	// we're still here - export successfully completed. Write result to the given IOSYstem
+	boost::scoped_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
+	if(outfile == NULL) {
+		throw DeadlyExportError("could not open output .stp file: " + std::string(pFile));
+	}
+
+	// XXX maybe use a small wrapper around IOStream that behaves like std::stringstream in order to avoid the extra copy.
+	outfile->Write( iDoTheExportThing.mOutput.str().c_str(), static_cast<size_t>(iDoTheExportThing.mOutput.tellp()),1);
+}
+
+} // end of namespace Assimp
+
+
+namespace {
+	// 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();
+		trafos[node] = parent * node->mTransformation;
+		for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+			CollectTrafos(node->mChildren[i], trafos);
+		}
+	}
+
+	// Generate a flat list of the meshes (by index) assigned to each node
+	void CollectMeshes(const aiNode* node, std::multimap<const aiNode*, unsigned int>& meshes) {
+		for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
+			meshes.insert(std::make_pair(node, node->mMeshes[i]));
+		}
+		for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+			CollectMeshes(node->mChildren[i], meshes);
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// 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) : mProperties(pProperties), mIOSystem(pIOSystem), mFile(file), mPath(path), mScene(pScene), endstr(";\n")
+{
+	CollectTrafos(pScene->mRootNode, trafos);
+	CollectMeshes(pScene->mRootNode, meshes);
+
+	// make sure that all formatting happens using the standard, C locale and not the user's current locale
+	mOutput.imbue( std::locale("C") );
+
+	// start writing
+	WriteFile();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Starts writing the contents
+void StepExporter::WriteFile()
+{
+	// see http://shodhganga.inflibnet.ac.in:8080/jspui/bitstream/10603/14116/11/11_chapter%203.pdf
+	// note, that all realnumber values must be comma separated in x files
+	mOutput.setf(std::ios::fixed);
+	mOutput.precision(16); // precission for double
+	
+	// standard color
+	aiColor4D fColor;
+	fColor.r = 0.8f;
+	fColor.g = 0.8f;
+	fColor.b = 0.8f;
+
+	int ind = 100; // the start index to be used
+	int faceEntryLen = 30; // number of entries for a triangle/face
+	// prepare unique (count triangles and vertices)
+
+	VectorIndexUMap uniqueVerts; // use a map to reduce find complexity to log(n)
+	VectorIndexUMap::iterator it;
+	int countFace = 0;
+
+	for (unsigned int i=0; i<mScene->mNumMeshes; ++i)
+	{
+		aiMesh* mesh = mScene->mMeshes[i];		
+		for (unsigned int j=0; j<mesh->mNumFaces; ++j)
+		{
+			aiFace* face = &(mesh->mFaces[j]);
+
+			if (face->mNumIndices == 3) countFace++;
+		}
+		for (unsigned int j=0; j<mesh->mNumVertices; ++j)
+		{
+			aiVector3D* v = &(mesh->mVertices[j]);
+			it =uniqueVerts.find(v); 
+			if (it == uniqueVerts.end())
+			{
+				uniqueVerts[v] = -1; // first mark the vector as not transformed
+			}
+		}
+	}
+
+	static const unsigned int date_nb_chars = 20;
+	char date_str[date_nb_chars];
+	std::time_t date = std::time(NULL);
+	std::strftime(date_str, date_nb_chars, "%Y-%m-%dT%H:%M:%S", std::localtime(&date));
+
+	// write the header	
+	mOutput << "ISO-10303-21" << endstr;
+	mOutput << "HEADER" << endstr;
+	mOutput << "FILE_DESCRIPTION(('STEP AP214'),'1')" << endstr;
+	mOutput << "FILE_NAME('" << mFile << ".stp','" << date_str << "',(' '),(' '),'Spatial InterOp 3D',' ',' ')" << endstr;
+	mOutput << "FILE_SCHEMA(('automotive_design'))" << endstr;
+	mOutput << "ENDSEC" << endstr;
+
+	// write the top of data
+	mOutput << "DATA" << endstr;
+	mOutput << "#1=MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION(' ',(";
+	for (int i=0; i<countFace; ++i)
+	{
+		mOutput << "#" << i*faceEntryLen + ind + 2*uniqueVerts.size();
+		if (i!=countFace-1) mOutput << ",";
+	}
+	mOutput << "),#6)" << endstr;
+
+	mOutput << "#2=PRODUCT_DEFINITION_CONTEXT('',#7,'design')" << endstr;
+	mOutput << "#3=APPLICATION_PROTOCOL_DEFINITION('INTERNATIONAL STANDARD','automotive_design',1994,#7)" << endstr;
+	mOutput << "#4=PRODUCT_CATEGORY_RELATIONSHIP('NONE','NONE',#8,#9)" << endstr;
+	mOutput << "#5=SHAPE_DEFINITION_REPRESENTATION(#10,#11)" << endstr;
+	mOutput << "#6= (GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#12))GLOBAL_UNIT_ASSIGNED_CONTEXT((#13,#14,#15))REPRESENTATION_CONTEXT('NONE','WORKSPACE'))" << endstr;
+	mOutput << "#7=APPLICATION_CONTEXT(' ')" << endstr;
+	mOutput << "#8=PRODUCT_CATEGORY('part','NONE')" << endstr;
+	mOutput << "#9=PRODUCT_RELATED_PRODUCT_CATEGORY('detail',' ',(#17))" << endstr;
+	mOutput << "#10=PRODUCT_DEFINITION_SHAPE('NONE','NONE',#18)" << endstr;
+	mOutput << "#11=MANIFOLD_SURFACE_SHAPE_REPRESENTATION('Root',(#16,#19),#6)" << endstr;
+	mOutput << "#12=UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.0E-006),#13,'','')" << endstr;
+	mOutput << "#13=(CONVERSION_BASED_UNIT('METRE',#20)LENGTH_UNIT()NAMED_UNIT(#21))" << endstr;
+	mOutput << "#14=(NAMED_UNIT(#22)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.))" << endstr;
+	mOutput << "#15=(NAMED_UNIT(#22)SOLID_ANGLE_UNIT()SI_UNIT($,.STERADIAN.))" << endstr;
+	mOutput << "#16=SHELL_BASED_SURFACE_MODEL('Root',(#29))" << endstr;
+	mOutput << "#17=PRODUCT('Root','Root','Root',(#23))" << endstr;
+	mOutput << "#18=PRODUCT_DEFINITION('NONE','NONE',#24,#2)" << endstr;
+	mOutput << "#19=AXIS2_PLACEMENT_3D('',#25,#26,#27)" << endstr;
+	mOutput << "#20=LENGTH_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.0),#28)" << endstr;
+	mOutput << "#21=DIMENSIONAL_EXPONENTS(1.0,0.0,0.0,0.0,0.0,0.0,0.0)" << endstr;
+	mOutput << "#22=DIMENSIONAL_EXPONENTS(0.0,0.0,0.0,0.0,0.0,0.0,0.0)" << endstr;
+	mOutput << "#23=PRODUCT_CONTEXT('',#7,'mechanical')" << endstr;
+	mOutput << "#24=PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE(' ','NONE',#17,.NOT_KNOWN.)" << endstr;
+	mOutput << "#25=CARTESIAN_POINT('',(0.0,0.0,0.0))" << endstr;
+	mOutput << "#26=DIRECTION('',(0.0,0.0,1.0))" << endstr;
+	mOutput << "#27=DIRECTION('',(1.0,0.0,0.0))" << endstr;	
+	mOutput << "#28= (NAMED_UNIT(#21)LENGTH_UNIT()SI_UNIT(.MILLI.,.METRE.))" << endstr;
+	mOutput << "#29=CLOSED_SHELL('',(";
+	for (int i=0; i<countFace; ++i)
+	{
+		mOutput << "#" << i*faceEntryLen + ind + 2*uniqueVerts.size() + 8;
+		if (i!=countFace-1) mOutput << ",";
+	}
+	mOutput << "))" << endstr;
+
+	// write all the unique transformed CARTESIAN and VERTEX
+	for (MeshesByNodeMap::const_iterator it2 = meshes.begin(); it2 != meshes.end(); it2++)
+	{
+		const aiNode& node = *(*it2).first;
+		unsigned int mesh_idx = (*it2).second;
+
+		const aiMesh* mesh = mScene->mMeshes[mesh_idx];
+		aiMatrix4x4& trafo = trafos[&node];
+		for (unsigned int i = 0; i < mesh->mNumVertices; ++i)
+		{
+			aiVector3D* v = &(mesh->mVertices[i]);
+			it = uniqueVerts.find(v);
+			if (it->second >=0 ) continue;
+			it->second = ind; // this one is new, so set the index (ind)
+			aiVector3D vt = trafo * (*v); // transform the coordinate
+			mOutput << "#" << it->second << "=CARTESIAN_POINT('',(" << vt.x << "," << vt.y << "," << vt.z << "))" << endstr;
+			mOutput << "#" << it->second+1 << "=VERTEX_POINT('',#" << it->second << ")" << endstr;
+			ind += 2;
+		}
+	}
+
+	// write the triangles
+	for (unsigned int i=0; i<mScene->mNumMeshes; ++i)
+	{
+		aiMesh* mesh = mScene->mMeshes[i];		
+		for (unsigned int j=0; j<mesh->mNumFaces; ++j)
+		{
+			aiFace* face = &(mesh->mFaces[j]);
+
+			if (face->mNumIndices != 3) continue;
+	
+			aiVector3D* v1 = &(mesh->mVertices[face->mIndices[0]]);
+			aiVector3D* v2 = &(mesh->mVertices[face->mIndices[1]]);
+			aiVector3D* v3 = &(mesh->mVertices[face->mIndices[2]]);
+			aiVector3D dv12 = *v2 - *v1;
+			aiVector3D dv23 = *v3 - *v2;
+			aiVector3D dv31 = *v1 - *v3;
+			aiVector3D dv13 = *v3 - *v1;
+			dv12.Normalize();
+			dv23.Normalize();
+			dv31.Normalize();
+			dv13.Normalize();
+
+			int pid1 = uniqueVerts.find(v1)->second;
+			int pid2 = uniqueVerts.find(v2)->second;
+			int pid3 = uniqueVerts.find(v3)->second;
+			
+			// mean vertex color for the face if available
+			if (mesh->HasVertexColors(0))
+			{					
+				fColor.r = 0.0;
+				fColor.g = 0.0;
+				fColor.b = 0.0;
+				fColor += mesh->mColors[0][face->mIndices[0]];
+				fColor += mesh->mColors[0][face->mIndices[1]];
+				fColor += mesh->mColors[0][face->mIndices[2]];
+				fColor /= 3.0f;
+			}
+
+			int sid = ind; // the sub index		
+			mOutput << "#" << sid << "=STYLED_ITEM('',(#" << sid+1 << "),#" << sid+8 << ")" << endstr; /* the item that must be referenced in #1 */
+			/* This is the color information of the Triangle */
+			mOutput << "#" << sid+1 << "=PRESENTATION_STYLE_ASSIGNMENT((#" << sid+2 << "))" << endstr;
+			mOutput << "#" << sid+2 << "=SURFACE_STYLE_USAGE(.BOTH.,#" << sid+3 << ")" << endstr;
+			mOutput << "#" << sid+3 << "=SURFACE_SIDE_STYLE('',(#" << sid+4 << "))" << endstr;
+			mOutput << "#" << sid+4 << "=SURFACE_STYLE_FILL_AREA(#" << sid+5 << ")" << endstr;
+			mOutput << "#" << sid+5 << "=FILL_AREA_STYLE('',(#" << sid+6 << "))" << endstr;
+			mOutput << "#" << sid+6 << "=FILL_AREA_STYLE_COLOUR('',#" << sid+7 << ")" << endstr;
+			mOutput << "#" << sid+7 << "=COLOUR_RGB(''," << fColor.r << "," << fColor.g << "," << fColor.b << ")" << endstr;
+
+			/* this is the geometry */
+			mOutput << "#" << sid+8 << "=FACE_SURFACE('',(#" << sid+13 << "),#" << sid+9<< ",.T.)" << endstr; /* the face that must be referenced in 29 */
+
+			/* 2 directions of the plane */
+			mOutput << "#" << sid+9 << "=PLANE('',#" << sid+10 << ")" << endstr;
+			mOutput << "#" << sid+10 << "=AXIS2_PLACEMENT_3D('',#" << pid1 << ", #" << sid+11 << ",#" << sid+12 << ")" << endstr;									
+
+			mOutput << "#" << sid+11 << "=DIRECTION('',(" << dv12.x << "," << dv12.y << "," << dv12.z << "))" << endstr;
+			mOutput << "#" << sid+12 << "=DIRECTION('',(" << dv13.x << "," << dv13.y << "," << dv13.z << "))" << endstr;
+
+			mOutput << "#" << sid+13 << "=FACE_BOUND('',#" << sid+14 << ",.T.)" << endstr;
+			mOutput << "#" << sid+14 << "=EDGE_LOOP('',(#" << sid+15 << ",#" << sid+16 << ",#" << sid+17 << "))" << endstr;
+
+			/* edge loop  */
+			mOutput << "#" << sid+15 << "=ORIENTED_EDGE('',*,*,#" << sid+18 << ",.T.)" << endstr;
+			mOutput << "#" << sid+16 << "=ORIENTED_EDGE('',*,*,#" << sid+19 << ",.T.)" << endstr;
+			mOutput << "#" << sid+17 << "=ORIENTED_EDGE('',*,*,#" << sid+20 << ",.T.)" << endstr;
+
+			/* oriented edges */
+			mOutput << "#" << sid+18 << "=EDGE_CURVE('',#" << pid1+1 << ",#" << pid2+1 << ",#" << sid+21 << ",.F.)" << endstr;
+			mOutput << "#" << sid+19 << "=EDGE_CURVE('',#" << pid2+1 << ",#" << pid3+1 << ",#" << sid+22 << ",.T.)" << endstr;
+			mOutput << "#" << sid+20 << "=EDGE_CURVE('',#" << pid3+1 << ",#" << pid1+1 << ",#" << sid+23 << ",.T.)" << endstr;
+
+			/* 3 lines and 3 vectors for the lines for the 3 edge curves */
+			mOutput << "#" << sid+21 << "=LINE('',#" << pid1 << ",#" << sid+24 << ")" << endstr;
+			mOutput << "#" << sid+22 << "=LINE('',#" << pid2 << ",#" << sid+25 << ")" << endstr;
+			mOutput << "#" << sid+23 << "=LINE('',#" << pid3 << ",#" << sid+26 << ")" << endstr;
+			mOutput << "#" << sid+24 << "=VECTOR('',#" << sid+27 << ",1.0)" << endstr;
+			mOutput << "#" << sid+25 << "=VECTOR('',#" << sid+28 << ",1.0)" << endstr;
+			mOutput << "#" << sid+26 << "=VECTOR('',#" << sid+29 << ",1.0)" << endstr;
+			mOutput << "#" << sid+27 << "=DIRECTION('',(" << dv12.x << "," << dv12.y << "," << dv12.z << "))" << endstr;
+			mOutput << "#" << sid+28 << "=DIRECTION('',(" << dv23.x << "," << dv23.y << "," << dv23.z << "))" << endstr;
+			mOutput << "#" << sid+29 << "=DIRECTION('',(" << dv31.x << "," << dv31.y << "," << dv31.z << "))" << endstr;
+			ind += faceEntryLen; // increase counter
+		}
+	}
+		
+	mOutput << "ENDSEC" << endstr; // end of data section	
+	mOutput << "END-ISO-10303-21" << endstr; // end of file
+}
+
+#endif
+#endif
+

code/StepExporter.h

@@ -0,0 +1,109 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, 
+with or without modification, are permitted provided that the 
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+@author: Richard Steffen, 2014
+
+----------------------------------------------------------------------
+*/
+
+/** @file StepExporter.h
+ * Declares the exporter class to write a scene to a Collada file
+ */
+#ifndef AI_STEPEXPORTER_H_INC
+#define AI_STEPEXPORTER_H_INC
+
+#include "../include/assimp/ai_assert.h"
+#include "../include/assimp/matrix4x4.h"
+#include "../include/assimp/Exporter.hpp"
+#include <sstream>
+
+
+struct aiScene;
+struct aiNode;
+
+namespace Assimp	
+{
+
+/// Helper class to export a given scene to a StepFile.
+/// Note: an StepFile uses a left hand system. Assimp used a right hand system (OpenGL), therefore we have to transform everything
+class StepExporter
+{
+public:
+	/// Constructor for a specific scene to export
+	StepExporter(const aiScene* pScene, IOSystem* pIOSystem, const std::string& path, const std::string& file, const ExportProperties* pProperties);
+
+protected:
+	/// Starts writing the contents
+	void WriteFile();	
+
+public:
+
+	/// Stringstream to write all output into
+	std::stringstream mOutput;
+
+protected:
+
+	/// hold the properties pointer
+	const ExportProperties* mProperties;	
+
+	/// The IOSystem for output
+	IOSystem* mIOSystem;
+
+	/// Name of the file (without extension) where the scene will be exported
+	std::string mFile;
+
+	/// Path of the directory where the scene will be exported
+	std::string mPath;	
+
+	/// The scene to be written
+	const aiScene* mScene;
+
+	/// current line end string for simple stream insertion
+	std::string endstr;
+
+	/// accumultated transformations for nodes
+	std::map<const aiNode*, aiMatrix4x4> trafos;
+
+	/// map to all meshed of nodes
+	typedef std::multimap<const aiNode*, unsigned int> MeshesByNodeMap;
+	MeshesByNodeMap meshes;
+
+};
+
+}
+
+#endif // !! AI_STEPEXPORTER_H_INC

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/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

@@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "BaseImporter.h"
 #include "fast_atof.h"
 #include "SceneCombiner.h"
-
+#include "DefaultIOSystem.h"
 #include <ctime>
 #include <set>
 #include <boost/scoped_ptr.hpp>
@@ -68,22 +68,8 @@ namespace Assimp
 // Worker function for exporting a scene to Collada. Prototyped and registered in Exporter.cpp
 void ExportSceneXFile(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
 {
-	std::string path = "";
+	std::string path = DefaultIOSystem::absolutePath(std::string(pFile));
-	std::string file = pFile;
+	std::string file = DefaultIOSystem::completeBaseName(std::string(pFile));
-
-	// We need to test both types of folder separators because pIOSystem->getOsSeparator() is not reliable.
-	// Moreover, the path given by some applications is not even consistent with the OS specific type of separator.
-	const char* end_path = std::max(strrchr(pFile, '\\'), strrchr(pFile, '/'));
-
-	if(end_path != NULL) {
-		path = std::string(pFile, end_path + 1 - pFile);
-		file = file.substr(end_path + 1 - pFile, file.npos);
-
-		std::size_t pos = file.find_last_of('.');
-		if(pos != file.npos) {
-			file = file.substr(0, pos);
-		}
-	}
 
 	// create/copy Properties
 	ExportProperties props(*pProperties);
@@ -109,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();
 }
@@ -326,8 +313,8 @@ void XFileExporter::WriteNode( aiNode* pNode)
 		WriteMesh(mScene->mMeshes[pNode->mMeshes[i]]);
 
 	// recursive call the Nodes
-	for (size_t a = 0; a < pNode->mNumChildren; a++)
+	for (size_t i = 0; i < pNode->mNumChildren; ++i)
-		WriteNode( mScene->mRootNode->mChildren[a]);
+		WriteNode( mScene->mRootNode->mChildren[i]);
 
 	PopTag();
 
@@ -514,12 +501,16 @@ void XFileExporter::WriteMesh(aiMesh* mesh)
 
 std::string XFileExporter::toXFileString(aiString &name)
 {
-	std::string str = std::string(name.C_Str());
+	std::string pref = ""; // node name prefix to prevent unexpected start of string
-	std::replace(str.begin(), str.end(), '<', '_');
+	std::string str = pref + std::string(name.C_Str());	
-	std::replace(str.begin(), str.end(), '>', '_');
+	for (int i=0; i < (int) str.length(); ++i)
-	std::replace(str.begin(), str.end(), '{', '_');
+	{
-	std::replace(str.begin(), str.end(), '}', '_');
+		if ((str[i] >= '0' && str[i] <= '9') || // 0-9
-	std::replace(str.begin(), str.end(), '$', '_');
+			(str[i] >= 'A' && str[i] <= 'Z') || // A-Z
+			(str[i] >= 'a' && str[i] <= 'z')) // a-z
+			continue;
+		str[i] = '_';
+	}
 	return str;
 }
 

code/XFileExporter.h

@@ -128,8 +128,6 @@ protected:
 	/// current line end string for simple stream insertion
 	std::string endstr;
   
-protected:
-
 };
 
 }

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/DDLNode.cpp

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

contrib/openddlparser/code/OpenDDLParser.cpp

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

contrib/openddlparser/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 ) {
@@ -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 {
+    if( m_type == ddl_float ) {
         float v;
         ::memcpy( &v, m_data, m_size );
-    return v;
+        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;
+
+    /// @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,13 +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)
@@ -42,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
 
@@ -63,57 +69,113 @@ 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.
 };
 
-struct Token {
+///	@brief  Stores a text
-public:
+struct Text {
-    Token( const char *token )
+    size_t m_capacity;
-    : m_token( token )
+    size_t m_len;
-    , m_size( 0 ){
+    char *m_buffer;
-        if( ddl_nullptr != token ) {
+
-            m_size = strlen( m_token );
+    Text( const char *buffer, size_t numChars )
+    : m_capacity( 0 )
+    , m_len( 0 )
+    , m_buffer( ddl_nullptr ) {
+        set( buffer, numChars );
+    }
+
+    ~Text() {
+        clear();
+    }
+
+    void clear() {
+        delete[] m_buffer;
+        m_buffer = ddl_nullptr;
+        m_capacity = 0;
+        m_len = 0;
+    }
+
+    void set( const char *buffer, size_t numChars ) {
+        clear();
+        if( numChars > 0 ) {
+            m_len = numChars;
+            m_capacity = m_len + 1;
+            m_buffer = new char[ m_capacity ];
+            strncpy( m_buffer, buffer, numChars );
+            m_buffer[ numChars ] = '\0';
         }
     }
 
-    ~Token() {
+    bool operator == ( const std::string &name ) const {
-        // empty
+        if( m_len != name.size() ) {
+            return false;
+        }
+        const int res( strncmp( m_buffer, name.c_str(), name.size() ) );
+        
+        return ( 0 == res );
     }
 
-    size_t length() const {
+    bool operator == ( const Text &rhs ) const {
-        return m_size;
+        if( m_len != rhs.m_len ) {
-    }
-
-    bool operator == ( const Token &rhs ) const {
-        if( m_size != rhs.m_size ) {
             return false;
         }
 
-        const int res( strncmp( m_token, rhs.m_token, m_size ) );
+        const int res( strncmp( m_buffer, rhs.m_buffer, m_len ) );
-        return ( res == 0 );
+        
+        return ( 0 == res );
     }
 
 private:
-    Token();
+    Text( const Text & );
-    Token( const Token  & );
+    Text &operator = ( const Text & );
-    Token &operator = ( const Token & );
-
-private:
-    const char *m_token;
-    size_t m_size;
 };
 
+///	@brief  Stores an OpenDDL-specific identifier type.
+struct Identifier {
+    Text m_text;
+
+    Identifier( char buffer[], size_t len )
+        : m_text( buffer, len ) {
+        // empty
+    }
+
+    Identifier( char buffer[] )
+    : m_text( buffer, strlen( buffer ) ) {
+        // empty
+    }
+
+    bool operator == ( const Identifier &rhs ) const {
+        return m_text == rhs.m_text;
+    }
+
+private:
+    Identifier( const Identifier & );
+    Identifier &operator = ( const Identifier & );
+};
+
+///	@brief  Stores an OpenDDL-specific name
 struct Name {
     NameType    m_type;
     Identifier *m_id;
@@ -129,6 +191,7 @@ private:
     Name &operator = ( const Name& );
 };
 
+///	@brief  Stores a bundle of references.
 struct Reference {
     size_t   m_numRefs;
     Name   **m_referencedName;
@@ -149,45 +212,47 @@ 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 & );
 };
 
-struct Identifier {
+///	@brief  Stores a property list.
-    size_t m_len;
-    char *m_buffer;
-
-    Identifier( size_t len, char buffer[] )
-        : m_len( len )
-        , m_buffer( buffer ) {
-        // empty
-    }
-
-private:
-    Identifier( const Identifier & );
-    Identifier &operator = ( const Identifier & );
-};
-
 struct Property {
-    Identifier *m_id;
+    Identifier *m_key;
-    Value *m_primData;
+    Value *m_value;
     Reference *m_ref;
     Property *m_next;
 
     Property( Identifier *id )
-        : m_id( id )
+    : m_key( id )
-        , m_primData( ddl_nullptr )
+    , m_value( ddl_nullptr )
     , m_ref( ddl_nullptr )
     , m_next( ddl_nullptr ) {
         // empty
     }
 
+    ~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;
@@ -203,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;
 
@@ -214,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>
 
@@ -107,6 +105,12 @@ bool isNumeric( const T in ) {
     return false;*/
 }
 
+template<class T>
+inline
+bool isNotEndOfToken( T *in, T *end ) {
+    return ( '}' != *in && ',' != *in && !isSpace( *in ) && in != end );
+}
+
 template<class T>
 inline
 bool isInteger( T *in, T *end ) {
@@ -117,7 +121,7 @@ bool isInteger( T *in, T *end ) {
     }
 
     bool result( false );
-    while( '}' != *in && ',' != *in && !isSpace( *in ) && in != end ) {
+    while( isNotEndOfToken( in, end ) ) {
         result = isNumeric( *in );
         if( !result ) {
             break;
@@ -139,7 +143,7 @@ bool isFloat( T *in, T *end ) {
 
     // check for <1>.0f
     bool result( false );
-    while( !isSpace( *in ) && in != end ) {
+    while( isNotEndOfToken( in, end ) ) {
         if( *in == '.' ) {
             result = true;
             break;
@@ -159,7 +163,7 @@ bool isFloat( T *in, T *end ) {
     }
 
     // check for 1.<0>f
-    while( !isSpace( *in ) && in != end && *in != ',' ) {
+    while( isNotEndOfToken( in, end ) ) {
         result = isNumeric( *in );
         if( !result ) {
             return false;
@@ -246,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;
-  }
-
-}

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

@@ -1,131 +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 aiColor3D : IDisposable {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiColor3D(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiColor3D obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiColor3D() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_aiColor3D(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public aiColor3D() : this(AssimpPINVOKE.new_aiColor3D__SWIG_0(), true) {
-  }
-
-  public aiColor3D(float _r, float _g, float _b) : this(AssimpPINVOKE.new_aiColor3D__SWIG_1(_r, _g, _b), true) {
-  }
-
-  public aiColor3D(float _r) : this(AssimpPINVOKE.new_aiColor3D__SWIG_2(_r), true) {
-  }
-
-  public aiColor3D(aiColor3D o) : this(AssimpPINVOKE.new_aiColor3D__SWIG_3(aiColor3D.getCPtr(o)), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public bool __equal__(aiColor3D other) {
-    bool ret = AssimpPINVOKE.aiColor3D___equal__(swigCPtr, aiColor3D.getCPtr(other));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public bool __nequal__(aiColor3D other) {
-    bool ret = AssimpPINVOKE.aiColor3D___nequal__(swigCPtr, aiColor3D.getCPtr(other));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public aiColor3D __add__(aiColor3D c) {
-    aiColor3D ret = new aiColor3D(AssimpPINVOKE.aiColor3D___add__(swigCPtr, aiColor3D.getCPtr(c)), true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public aiColor3D __sub__(aiColor3D c) {
-    aiColor3D ret = new aiColor3D(AssimpPINVOKE.aiColor3D___sub__(swigCPtr, aiColor3D.getCPtr(c)), true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public aiColor3D __mul__(aiColor3D c) {
-    aiColor3D ret = new aiColor3D(AssimpPINVOKE.aiColor3D___mul____SWIG_0(swigCPtr, aiColor3D.getCPtr(c)), true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public aiColor3D __mul__(float f) {
-    aiColor3D ret = new aiColor3D(AssimpPINVOKE.aiColor3D___mul____SWIG_1(swigCPtr, f), true);
-    return ret;
-  }
-
-  public float __idx__(uint i) {
-    float ret = AssimpPINVOKE.aiColor3D___idx____SWIG_0(swigCPtr, i);
-    return ret;
-  }
-
-  public bool IsBlack() {
-    bool ret = AssimpPINVOKE.aiColor3D_IsBlack(swigCPtr);
-    return ret;
-  }
-
-  public float r {
-    set {
-      AssimpPINVOKE.aiColor3D_r_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiColor3D_r_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public float g {
-    set {
-      AssimpPINVOKE.aiColor3D_g_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiColor3D_g_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public float b {
-    set {
-      AssimpPINVOKE.aiColor3D_b_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiColor3D_b_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-}

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

@@ -1,140 +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 aiColor4D : IDisposable {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiColor4D(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiColor4D obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiColor4D() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_aiColor4D(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public aiColor4D() : this(AssimpPINVOKE.new_aiColor4D__SWIG_0(), true) {
-  }
-
-  public aiColor4D(float _r, float _g, float _b, float _a) : this(AssimpPINVOKE.new_aiColor4D__SWIG_1(_r, _g, _b, _a), true) {
-  }
-
-  public aiColor4D(float _r) : this(AssimpPINVOKE.new_aiColor4D__SWIG_2(_r), true) {
-  }
-
-  public aiColor4D(aiColor4D o) : this(AssimpPINVOKE.new_aiColor4D__SWIG_3(aiColor4D.getCPtr(o)), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiColor4D __addnset__(aiColor4D o) {
-    aiColor4D ret = new aiColor4D(AssimpPINVOKE.aiColor4D___addnset__(swigCPtr, aiColor4D.getCPtr(o)), false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public aiColor4D __subnset__(aiColor4D o) {
-    aiColor4D ret = new aiColor4D(AssimpPINVOKE.aiColor4D___subnset__(swigCPtr, aiColor4D.getCPtr(o)), false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public aiColor4D __mulnset__(float f) {
-    aiColor4D ret = new aiColor4D(AssimpPINVOKE.aiColor4D___mulnset__(swigCPtr, f), false);
-    return ret;
-  }
-
-  public aiColor4D __divnset__(float f) {
-    aiColor4D ret = new aiColor4D(AssimpPINVOKE.aiColor4D___divnset__(swigCPtr, f), false);
-    return ret;
-  }
-
-  public bool __equal__(aiColor4D other) {
-    bool ret = AssimpPINVOKE.aiColor4D___equal__(swigCPtr, aiColor4D.getCPtr(other));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public bool __nequal__(aiColor4D other) {
-    bool ret = AssimpPINVOKE.aiColor4D___nequal__(swigCPtr, aiColor4D.getCPtr(other));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public float __idx__(uint i) {
-    float ret = AssimpPINVOKE.aiColor4D___idx____SWIG_0(swigCPtr, i);
-    return ret;
-  }
-
-  public bool IsBlack() {
-    bool ret = AssimpPINVOKE.aiColor4D_IsBlack(swigCPtr);
-    return ret;
-  }
-
-  public float r {
-    set {
-      AssimpPINVOKE.aiColor4D_r_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiColor4D_r_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public float g {
-    set {
-      AssimpPINVOKE.aiColor4D_g_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiColor4D_g_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public float b {
-    set {
-      AssimpPINVOKE.aiColor4D_b_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiColor4D_b_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public float a {
-    set {
-      AssimpPINVOKE.aiColor4D_a_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiColor4D_a_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-}

port/Assimp.NET/Assimp.NET_CS/aiColor4DVector.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 aiColor4DVector : IDisposable, System.Collections.IEnumerable
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IList<aiColor4D>
-#endif
- {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiColor4DVector(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiColor4DVector obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiColor4DVector() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_aiColor4DVector(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public aiColor4DVector(System.Collections.ICollection c) : this() {
-    if (c == null)
-      throw new ArgumentNullException("c");
-    foreach (aiColor4D element in c) {
-      this.Add(element);
-    }
-  }
-
-  public bool IsFixedSize {
-    get {
-      return false;
-    }
-  }
-
-  public bool IsReadOnly {
-    get {
-      return false;
-    }
-  }
-
-  public aiColor4D 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(aiColor4D[] array)
-#endif
-  {
-    CopyTo(0, array, 0, this.Count);
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(System.Array array, int arrayIndex)
-#else
-  public void CopyTo(aiColor4D[] 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, aiColor4D[] 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<aiColor4D> System.Collections.Generic.IEnumerable<aiColor4D>.GetEnumerator() {
-    return new aiColor4DVectorEnumerator(this);
-  }
-#endif
-
-  System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
-    return new aiColor4DVectorEnumerator(this);
-  }
-
-  public aiColor4DVectorEnumerator GetEnumerator() {
-    return new aiColor4DVectorEnumerator(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 aiColor4DVectorEnumerator : System.Collections.IEnumerator
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IEnumerator<aiColor4D>
-#endif
-  {
-    private aiColor4DVector collectionRef;
-    private int currentIndex;
-    private object currentObject;
-    private int currentSize;
-
-    public aiColor4DVectorEnumerator(aiColor4DVector collection) {
-      collectionRef = collection;
-      currentIndex = -1;
-      currentObject = null;
-      currentSize = collectionRef.Count;
-    }
-
-    // Type-safe iterator Current
-    public aiColor4D 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 (aiColor4D)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.aiColor4DVector_Clear(swigCPtr);
-  }
-
-  public void Add(aiColor4D x) {
-    AssimpPINVOKE.aiColor4DVector_Add(swigCPtr, aiColor4D.getCPtr(x));
-  }
-
-  private uint size() {
-    uint ret = AssimpPINVOKE.aiColor4DVector_size(swigCPtr);
-    return ret;
-  }
-
-  private uint capacity() {
-    uint ret = AssimpPINVOKE.aiColor4DVector_capacity(swigCPtr);
-    return ret;
-  }
-
-  private void reserve(uint n) {
-    AssimpPINVOKE.aiColor4DVector_reserve(swigCPtr, n);
-  }
-
-  public aiColor4DVector() : this(AssimpPINVOKE.new_aiColor4DVector__SWIG_0(), true) {
-  }
-
-  public aiColor4DVector(aiColor4DVector other) : this(AssimpPINVOKE.new_aiColor4DVector__SWIG_1(aiColor4DVector.getCPtr(other)), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiColor4DVector(int capacity) : this(AssimpPINVOKE.new_aiColor4DVector__SWIG_2(capacity), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  private aiColor4D getitemcopy(int index) {
-    IntPtr cPtr = AssimpPINVOKE.aiColor4DVector_getitemcopy(swigCPtr, index);
-    aiColor4D ret = (cPtr == IntPtr.Zero) ? null : new aiColor4D(cPtr, false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private aiColor4D getitem(int index) {
-    IntPtr cPtr = AssimpPINVOKE.aiColor4DVector_getitem(swigCPtr, index);
-    aiColor4D ret = (cPtr == IntPtr.Zero) ? null : new aiColor4D(cPtr, false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private void setitem(int index, aiColor4D val) {
-    AssimpPINVOKE.aiColor4DVector_setitem(swigCPtr, index, aiColor4D.getCPtr(val));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void AddRange(aiColor4DVector values) {
-    AssimpPINVOKE.aiColor4DVector_AddRange(swigCPtr, aiColor4DVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiColor4DVector GetRange(int index, int count) {
-    IntPtr cPtr = AssimpPINVOKE.aiColor4DVector_GetRange(swigCPtr, index, count);
-    aiColor4DVector ret = (cPtr == IntPtr.Zero) ? null : new aiColor4DVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Insert(int index, aiColor4D x) {
-    AssimpPINVOKE.aiColor4DVector_Insert(swigCPtr, index, aiColor4D.getCPtr(x));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void InsertRange(int index, aiColor4DVector values) {
-    AssimpPINVOKE.aiColor4DVector_InsertRange(swigCPtr, index, aiColor4DVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveAt(int index) {
-    AssimpPINVOKE.aiColor4DVector_RemoveAt(swigCPtr, index);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveRange(int index, int count) {
-    AssimpPINVOKE.aiColor4DVector_RemoveRange(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public static aiColor4DVector Repeat(aiColor4D value, int count) {
-    IntPtr cPtr = AssimpPINVOKE.aiColor4DVector_Repeat(aiColor4D.getCPtr(value), count);
-    aiColor4DVector ret = (cPtr == IntPtr.Zero) ? null : new aiColor4DVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Reverse() {
-    AssimpPINVOKE.aiColor4DVector_Reverse__SWIG_0(swigCPtr);
-  }
-
-  public void Reverse(int index, int count) {
-    AssimpPINVOKE.aiColor4DVector_Reverse__SWIG_1(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void SetRange(int index, aiColor4DVector values) {
-    AssimpPINVOKE.aiColor4DVector_SetRange(swigCPtr, index, aiColor4DVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public bool Contains(aiColor4D value) {
-    bool ret = AssimpPINVOKE.aiColor4DVector_Contains(swigCPtr, aiColor4D.getCPtr(value));
-    return ret;
-  }
-
-  public int IndexOf(aiColor4D value) {
-    int ret = AssimpPINVOKE.aiColor4DVector_IndexOf(swigCPtr, aiColor4D.getCPtr(value));
-    return ret;
-  }
-
-  public int LastIndexOf(aiColor4D value) {
-    int ret = AssimpPINVOKE.aiColor4DVector_LastIndexOf(swigCPtr, aiColor4D.getCPtr(value));
-    return ret;
-  }
-
-  public bool Remove(aiColor4D value) {
-    bool ret = AssimpPINVOKE.aiColor4DVector_Remove(swigCPtr, aiColor4D.getCPtr(value));
-    return ret;
-  }
-
-}

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

@@ -1,327 +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 aiColor4DVectorVector : IDisposable, System.Collections.IEnumerable
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IEnumerable<aiColor4DVector>
-#endif
- {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiColor4DVectorVector(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiColor4DVectorVector obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiColor4DVectorVector() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_aiColor4DVectorVector(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public aiColor4DVectorVector(System.Collections.ICollection c) : this() {
-    if (c == null)
-      throw new ArgumentNullException("c");
-    foreach (aiColor4DVector element in c) {
-      this.Add(element);
-    }
-  }
-
-  public bool IsFixedSize {
-    get {
-      return false;
-    }
-  }
-
-  public bool IsReadOnly {
-    get {
-      return false;
-    }
-  }
-
-  public aiColor4DVector 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(aiColor4DVector[] array)
-#endif
-  {
-    CopyTo(0, array, 0, this.Count);
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(System.Array array, int arrayIndex)
-#else
-  public void CopyTo(aiColor4DVector[] 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, aiColor4DVector[] 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<aiColor4DVector> System.Collections.Generic.IEnumerable<aiColor4DVector>.GetEnumerator() {
-    return new aiColor4DVectorVectorEnumerator(this);
-  }
-#endif
-
-  System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
-    return new aiColor4DVectorVectorEnumerator(this);
-  }
-
-  public aiColor4DVectorVectorEnumerator GetEnumerator() {
-    return new aiColor4DVectorVectorEnumerator(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 aiColor4DVectorVectorEnumerator : System.Collections.IEnumerator
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IEnumerator<aiColor4DVector>
-#endif
-  {
-    private aiColor4DVectorVector collectionRef;
-    private int currentIndex;
-    private object currentObject;
-    private int currentSize;
-
-    public aiColor4DVectorVectorEnumerator(aiColor4DVectorVector collection) {
-      collectionRef = collection;
-      currentIndex = -1;
-      currentObject = null;
-      currentSize = collectionRef.Count;
-    }
-
-    // Type-safe iterator Current
-    public aiColor4DVector 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 (aiColor4DVector)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.aiColor4DVectorVector_Clear(swigCPtr);
-  }
-
-  public void Add(aiColor4DVector x) {
-    AssimpPINVOKE.aiColor4DVectorVector_Add(swigCPtr, aiColor4DVector.getCPtr(x));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  private uint size() {
-    uint ret = AssimpPINVOKE.aiColor4DVectorVector_size(swigCPtr);
-    return ret;
-  }
-
-  private uint capacity() {
-    uint ret = AssimpPINVOKE.aiColor4DVectorVector_capacity(swigCPtr);
-    return ret;
-  }
-
-  private void reserve(uint n) {
-    AssimpPINVOKE.aiColor4DVectorVector_reserve(swigCPtr, n);
-  }
-
-  public aiColor4DVectorVector() : this(AssimpPINVOKE.new_aiColor4DVectorVector__SWIG_0(), true) {
-  }
-
-  public aiColor4DVectorVector(aiColor4DVectorVector other) : this(AssimpPINVOKE.new_aiColor4DVectorVector__SWIG_1(aiColor4DVectorVector.getCPtr(other)), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiColor4DVectorVector(int capacity) : this(AssimpPINVOKE.new_aiColor4DVectorVector__SWIG_2(capacity), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  private aiColor4DVector getitemcopy(int index) {
-    aiColor4DVector ret = new aiColor4DVector(AssimpPINVOKE.aiColor4DVectorVector_getitemcopy(swigCPtr, index), true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private aiColor4DVector getitem(int index) {
-    aiColor4DVector ret = new aiColor4DVector(AssimpPINVOKE.aiColor4DVectorVector_getitem(swigCPtr, index), false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private void setitem(int index, aiColor4DVector val) {
-    AssimpPINVOKE.aiColor4DVectorVector_setitem(swigCPtr, index, aiColor4DVector.getCPtr(val));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void AddRange(aiColor4DVectorVector values) {
-    AssimpPINVOKE.aiColor4DVectorVector_AddRange(swigCPtr, aiColor4DVectorVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiColor4DVectorVector GetRange(int index, int count) {
-    IntPtr cPtr = AssimpPINVOKE.aiColor4DVectorVector_GetRange(swigCPtr, index, count);
-    aiColor4DVectorVector ret = (cPtr == IntPtr.Zero) ? null : new aiColor4DVectorVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Insert(int index, aiColor4DVector x) {
-    AssimpPINVOKE.aiColor4DVectorVector_Insert(swigCPtr, index, aiColor4DVector.getCPtr(x));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void InsertRange(int index, aiColor4DVectorVector values) {
-    AssimpPINVOKE.aiColor4DVectorVector_InsertRange(swigCPtr, index, aiColor4DVectorVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveAt(int index) {
-    AssimpPINVOKE.aiColor4DVectorVector_RemoveAt(swigCPtr, index);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveRange(int index, int count) {
-    AssimpPINVOKE.aiColor4DVectorVector_RemoveRange(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public static aiColor4DVectorVector Repeat(aiColor4DVector value, int count) {
-    IntPtr cPtr = AssimpPINVOKE.aiColor4DVectorVector_Repeat(aiColor4DVector.getCPtr(value), count);
-    aiColor4DVectorVector ret = (cPtr == IntPtr.Zero) ? null : new aiColor4DVectorVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Reverse() {
-    AssimpPINVOKE.aiColor4DVectorVector_Reverse__SWIG_0(swigCPtr);
-  }
-
-  public void Reverse(int index, int count) {
-    AssimpPINVOKE.aiColor4DVectorVector_Reverse__SWIG_1(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void SetRange(int index, aiColor4DVectorVector values) {
-    AssimpPINVOKE.aiColor4DVectorVector_SetRange(swigCPtr, index, aiColor4DVectorVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-}

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

@@ -1,22 +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 aiComponent {
-  aiComponent_NORMALS = 0x2,
-  aiComponent_TANGENTS_AND_BITANGENTS = 0x4,
-  aiComponent_COLORS = 0x8,
-  aiComponent_TEXCOORDS = 0x10,
-  aiComponent_BONEWEIGHTS = 0x20,
-  aiComponent_ANIMATIONS = 0x40,
-  aiComponent_TEXTURES = 0x80,
-  aiComponent_LIGHTS = 0x100,
-  aiComponent_CAMERAS = 0x200,
-  aiComponent_MESHES = 0x400,
-  aiComponent_MATERIALS = 0x800
-}

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

@@ -1,16 +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 aiDefaultLogStream {
-  aiDefaultLogStream_FILE = 0x1,
-  aiDefaultLogStream_STDOUT = 0x2,
-  aiDefaultLogStream_STDERR = 0x4,
-  aiDefaultLogStream_DEBUGGER = 0x8,
-  _AI_DLS_ENFORCE_ENUM_SIZE = 0x7fffffff
-}

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

@@ -1,86 +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 aiFace : IDisposable {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiFace(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiFace obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiFace() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_aiFace(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public UintVector mIndices { get { return GetmIndices(); } }
-
-  public uint mNumIndices {
-    set {
-      AssimpPINVOKE.aiFace_mNumIndices_set(swigCPtr, value);
-    } 
-    get {
-      uint ret = AssimpPINVOKE.aiFace_mNumIndices_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public aiFace() : this(AssimpPINVOKE.new_aiFace__SWIG_0(), true) {
-  }
-
-  public aiFace(aiFace o) : this(AssimpPINVOKE.new_aiFace__SWIG_1(aiFace.getCPtr(o)), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiFace __set__(aiFace o) {
-    aiFace ret = new aiFace(AssimpPINVOKE.aiFace___set__(swigCPtr, aiFace.getCPtr(o)), false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public bool __equal__(aiFace o) {
-    bool ret = AssimpPINVOKE.aiFace___equal__(swigCPtr, aiFace.getCPtr(o));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public bool __nequal__(aiFace o) {
-    bool ret = AssimpPINVOKE.aiFace___nequal__(swigCPtr, aiFace.getCPtr(o));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private UintVector GetmIndices() {
-    IntPtr cPtr = AssimpPINVOKE.aiFace_GetmIndices(swigCPtr);
-    UintVector ret = (cPtr == IntPtr.Zero) ? null : new UintVector(cPtr, true);
-    return ret;
-  }
-
-}

port/Assimp.NET/Assimp.NET_CS/aiFaceVector.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 aiFaceVector : IDisposable, System.Collections.IEnumerable
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IList<aiFace>
-#endif
- {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiFaceVector(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiFaceVector obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiFaceVector() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_aiFaceVector(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public aiFaceVector(System.Collections.ICollection c) : this() {
-    if (c == null)
-      throw new ArgumentNullException("c");
-    foreach (aiFace element in c) {
-      this.Add(element);
-    }
-  }
-
-  public bool IsFixedSize {
-    get {
-      return false;
-    }
-  }
-
-  public bool IsReadOnly {
-    get {
-      return false;
-    }
-  }
-
-  public aiFace 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(aiFace[] array)
-#endif
-  {
-    CopyTo(0, array, 0, this.Count);
-  }
-
-#if SWIG_DOTNET_1
-  public void CopyTo(System.Array array, int arrayIndex)
-#else
-  public void CopyTo(aiFace[] 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, aiFace[] 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<aiFace> System.Collections.Generic.IEnumerable<aiFace>.GetEnumerator() {
-    return new aiFaceVectorEnumerator(this);
-  }
-#endif
-
-  System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
-    return new aiFaceVectorEnumerator(this);
-  }
-
-  public aiFaceVectorEnumerator GetEnumerator() {
-    return new aiFaceVectorEnumerator(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 aiFaceVectorEnumerator : System.Collections.IEnumerator
-#if !SWIG_DOTNET_1
-    , System.Collections.Generic.IEnumerator<aiFace>
-#endif
-  {
-    private aiFaceVector collectionRef;
-    private int currentIndex;
-    private object currentObject;
-    private int currentSize;
-
-    public aiFaceVectorEnumerator(aiFaceVector collection) {
-      collectionRef = collection;
-      currentIndex = -1;
-      currentObject = null;
-      currentSize = collectionRef.Count;
-    }
-
-    // Type-safe iterator Current
-    public aiFace 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 (aiFace)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.aiFaceVector_Clear(swigCPtr);
-  }
-
-  public void Add(aiFace x) {
-    AssimpPINVOKE.aiFaceVector_Add(swigCPtr, aiFace.getCPtr(x));
-  }
-
-  private uint size() {
-    uint ret = AssimpPINVOKE.aiFaceVector_size(swigCPtr);
-    return ret;
-  }
-
-  private uint capacity() {
-    uint ret = AssimpPINVOKE.aiFaceVector_capacity(swigCPtr);
-    return ret;
-  }
-
-  private void reserve(uint n) {
-    AssimpPINVOKE.aiFaceVector_reserve(swigCPtr, n);
-  }
-
-  public aiFaceVector() : this(AssimpPINVOKE.new_aiFaceVector__SWIG_0(), true) {
-  }
-
-  public aiFaceVector(aiFaceVector other) : this(AssimpPINVOKE.new_aiFaceVector__SWIG_1(aiFaceVector.getCPtr(other)), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiFaceVector(int capacity) : this(AssimpPINVOKE.new_aiFaceVector__SWIG_2(capacity), true) {
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  private aiFace getitemcopy(int index) {
-    IntPtr cPtr = AssimpPINVOKE.aiFaceVector_getitemcopy(swigCPtr, index);
-    aiFace ret = (cPtr == IntPtr.Zero) ? null : new aiFace(cPtr, false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private aiFace getitem(int index) {
-    IntPtr cPtr = AssimpPINVOKE.aiFaceVector_getitem(swigCPtr, index);
-    aiFace ret = (cPtr == IntPtr.Zero) ? null : new aiFace(cPtr, false);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  private void setitem(int index, aiFace val) {
-    AssimpPINVOKE.aiFaceVector_setitem(swigCPtr, index, aiFace.getCPtr(val));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void AddRange(aiFaceVector values) {
-    AssimpPINVOKE.aiFaceVector_AddRange(swigCPtr, aiFaceVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public aiFaceVector GetRange(int index, int count) {
-    IntPtr cPtr = AssimpPINVOKE.aiFaceVector_GetRange(swigCPtr, index, count);
-    aiFaceVector ret = (cPtr == IntPtr.Zero) ? null : new aiFaceVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Insert(int index, aiFace x) {
-    AssimpPINVOKE.aiFaceVector_Insert(swigCPtr, index, aiFace.getCPtr(x));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void InsertRange(int index, aiFaceVector values) {
-    AssimpPINVOKE.aiFaceVector_InsertRange(swigCPtr, index, aiFaceVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveAt(int index) {
-    AssimpPINVOKE.aiFaceVector_RemoveAt(swigCPtr, index);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void RemoveRange(int index, int count) {
-    AssimpPINVOKE.aiFaceVector_RemoveRange(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public static aiFaceVector Repeat(aiFace value, int count) {
-    IntPtr cPtr = AssimpPINVOKE.aiFaceVector_Repeat(aiFace.getCPtr(value), count);
-    aiFaceVector ret = (cPtr == IntPtr.Zero) ? null : new aiFaceVector(cPtr, true);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-    return ret;
-  }
-
-  public void Reverse() {
-    AssimpPINVOKE.aiFaceVector_Reverse__SWIG_0(swigCPtr);
-  }
-
-  public void Reverse(int index, int count) {
-    AssimpPINVOKE.aiFaceVector_Reverse__SWIG_1(swigCPtr, index, count);
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public void SetRange(int index, aiFaceVector values) {
-    AssimpPINVOKE.aiFaceVector_SetRange(swigCPtr, index, aiFaceVector.getCPtr(values));
-    if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
-  }
-
-  public bool Contains(aiFace value) {
-    bool ret = AssimpPINVOKE.aiFaceVector_Contains(swigCPtr, aiFace.getCPtr(value));
-    return ret;
-  }
-
-  public int IndexOf(aiFace value) {
-    int ret = AssimpPINVOKE.aiFaceVector_IndexOf(swigCPtr, aiFace.getCPtr(value));
-    return ret;
-  }
-
-  public int LastIndexOf(aiFace value) {
-    int ret = AssimpPINVOKE.aiFaceVector_LastIndexOf(swigCPtr, aiFace.getCPtr(value));
-    return ret;
-  }
-
-  public bool Remove(aiFace value) {
-    bool ret = AssimpPINVOKE.aiFaceVector_Remove(swigCPtr, aiFace.getCPtr(value));
-    return ret;
-  }
-
-}

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

@@ -1,122 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.40
- *
- * 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 aiFile : IDisposable {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiFile(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiFile obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiFile() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          Assimp_NETPINVOKE.delete_aiFile(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public SWIGTYPE_p_f_p_aiFile_p_char_size_t_size_t__size_t ReadProc {
-    set {
-      Assimp_NETPINVOKE.aiFile_ReadProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFile_p_char_size_t_size_t__size_t.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = Assimp_NETPINVOKE.aiFile_ReadProc_get(swigCPtr);
-      SWIGTYPE_p_f_p_aiFile_p_char_size_t_size_t__size_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFile_p_char_size_t_size_t__size_t(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public SWIGTYPE_p_f_p_aiFile_p_q_const__char_size_t_size_t__size_t WriteProc {
-    set {
-      Assimp_NETPINVOKE.aiFile_WriteProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFile_p_q_const__char_size_t_size_t__size_t.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = Assimp_NETPINVOKE.aiFile_WriteProc_get(swigCPtr);
-      SWIGTYPE_p_f_p_aiFile_p_q_const__char_size_t_size_t__size_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFile_p_q_const__char_size_t_size_t__size_t(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public SWIGTYPE_p_f_p_aiFile__size_t TellProc {
-    set {
-      Assimp_NETPINVOKE.aiFile_TellProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFile__size_t.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = Assimp_NETPINVOKE.aiFile_TellProc_get(swigCPtr);
-      SWIGTYPE_p_f_p_aiFile__size_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFile__size_t(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public SWIGTYPE_p_f_p_aiFile__size_t FileSizeProc {
-    set {
-      Assimp_NETPINVOKE.aiFile_FileSizeProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFile__size_t.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = Assimp_NETPINVOKE.aiFile_FileSizeProc_get(swigCPtr);
-      SWIGTYPE_p_f_p_aiFile__size_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFile__size_t(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public SWIGTYPE_p_f_p_aiFile_size_t_enum_aiOrigin__aiReturn SeekProc {
-    set {
-      Assimp_NETPINVOKE.aiFile_SeekProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFile_size_t_enum_aiOrigin__aiReturn.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = Assimp_NETPINVOKE.aiFile_SeekProc_get(swigCPtr);
-      SWIGTYPE_p_f_p_aiFile_size_t_enum_aiOrigin__aiReturn ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFile_size_t_enum_aiOrigin__aiReturn(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public SWIGTYPE_p_f_p_aiFile__void FlushProc {
-    set {
-      Assimp_NETPINVOKE.aiFile_FlushProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFile__void.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = Assimp_NETPINVOKE.aiFile_FlushProc_get(swigCPtr);
-      SWIGTYPE_p_f_p_aiFile__void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFile__void(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public string UserData {
-    set {
-      Assimp_NETPINVOKE.aiFile_UserData_set(swigCPtr, value);
-    } 
-    get {
-      string ret = Assimp_NETPINVOKE.aiFile_UserData_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public aiFile() : this(Assimp_NETPINVOKE.new_aiFile(), true) {
-  }
-
-}

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

@@ -1,78 +0,0 @@
-/* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.40
- *
- * 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 aiFileIO : IDisposable {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiFileIO(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiFileIO obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiFileIO() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          Assimp_NETPINVOKE.delete_aiFileIO(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public SWIGTYPE_p_f_p_aiFileIO_p_q_const__char_p_q_const__char__p_aiFile OpenProc {
-    set {
-      Assimp_NETPINVOKE.aiFileIO_OpenProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFileIO_p_q_const__char_p_q_const__char__p_aiFile.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = Assimp_NETPINVOKE.aiFileIO_OpenProc_get(swigCPtr);
-      SWIGTYPE_p_f_p_aiFileIO_p_q_const__char_p_q_const__char__p_aiFile ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFileIO_p_q_const__char_p_q_const__char__p_aiFile(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public SWIGTYPE_p_f_p_aiFileIO_p_aiFile__void CloseProc {
-    set {
-      Assimp_NETPINVOKE.aiFileIO_CloseProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFileIO_p_aiFile__void.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = Assimp_NETPINVOKE.aiFileIO_CloseProc_get(swigCPtr);
-      SWIGTYPE_p_f_p_aiFileIO_p_aiFile__void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFileIO_p_aiFile__void(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public string UserData {
-    set {
-      Assimp_NETPINVOKE.aiFileIO_UserData_set(swigCPtr, value);
-    } 
-    get {
-      string ret = Assimp_NETPINVOKE.aiFileIO_UserData_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public aiFileIO() : this(Assimp_NETPINVOKE.new_aiFileIO(), true) {
-  }
-
-}

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

@@ -1,172 +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 aiLight : IDisposable {
-  private HandleRef swigCPtr;
-  protected bool swigCMemOwn;
-
-  internal aiLight(IntPtr cPtr, bool cMemoryOwn) {
-    swigCMemOwn = cMemoryOwn;
-    swigCPtr = new HandleRef(this, cPtr);
-  }
-
-  internal static HandleRef getCPtr(aiLight obj) {
-    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
-  }
-
-  ~aiLight() {
-    Dispose();
-  }
-
-  public virtual void Dispose() {
-    lock(this) {
-      if (swigCPtr.Handle != IntPtr.Zero) {
-        if (swigCMemOwn) {
-          swigCMemOwn = false;
-          AssimpPINVOKE.delete_aiLight(swigCPtr);
-        }
-        swigCPtr = new HandleRef(null, IntPtr.Zero);
-      }
-      GC.SuppressFinalize(this);
-    }
-  }
-
-  public aiString mName {
-    set {
-      AssimpPINVOKE.aiLight_mName_set(swigCPtr, aiString.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = AssimpPINVOKE.aiLight_mName_get(swigCPtr);
-      aiString ret = (cPtr == IntPtr.Zero) ? null : new aiString(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public aiLightSourceType mType {
-    set {
-      AssimpPINVOKE.aiLight_mType_set(swigCPtr, (int)value);
-    } 
-    get {
-      aiLightSourceType ret = (aiLightSourceType)AssimpPINVOKE.aiLight_mType_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public aiVector3D mPosition {
-    set {
-      AssimpPINVOKE.aiLight_mPosition_set(swigCPtr, aiVector3D.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = AssimpPINVOKE.aiLight_mPosition_get(swigCPtr);
-      aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public aiVector3D mDirection {
-    set {
-      AssimpPINVOKE.aiLight_mDirection_set(swigCPtr, aiVector3D.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = AssimpPINVOKE.aiLight_mDirection_get(swigCPtr);
-      aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public float mAttenuationConstant {
-    set {
-      AssimpPINVOKE.aiLight_mAttenuationConstant_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiLight_mAttenuationConstant_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public float mAttenuationLinear {
-    set {
-      AssimpPINVOKE.aiLight_mAttenuationLinear_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiLight_mAttenuationLinear_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public float mAttenuationQuadratic {
-    set {
-      AssimpPINVOKE.aiLight_mAttenuationQuadratic_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiLight_mAttenuationQuadratic_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public aiColor3D mColorDiffuse {
-    set {
-      AssimpPINVOKE.aiLight_mColorDiffuse_set(swigCPtr, aiColor3D.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = AssimpPINVOKE.aiLight_mColorDiffuse_get(swigCPtr);
-      aiColor3D ret = (cPtr == IntPtr.Zero) ? null : new aiColor3D(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public aiColor3D mColorSpecular {
-    set {
-      AssimpPINVOKE.aiLight_mColorSpecular_set(swigCPtr, aiColor3D.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = AssimpPINVOKE.aiLight_mColorSpecular_get(swigCPtr);
-      aiColor3D ret = (cPtr == IntPtr.Zero) ? null : new aiColor3D(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public aiColor3D mColorAmbient {
-    set {
-      AssimpPINVOKE.aiLight_mColorAmbient_set(swigCPtr, aiColor3D.getCPtr(value));
-    } 
-    get {
-      IntPtr cPtr = AssimpPINVOKE.aiLight_mColorAmbient_get(swigCPtr);
-      aiColor3D ret = (cPtr == IntPtr.Zero) ? null : new aiColor3D(cPtr, false);
-      return ret;
-    } 
-  }
-
-  public float mAngleInnerCone {
-    set {
-      AssimpPINVOKE.aiLight_mAngleInnerCone_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiLight_mAngleInnerCone_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public float mAngleOuterCone {
-    set {
-      AssimpPINVOKE.aiLight_mAngleOuterCone_set(swigCPtr, value);
-    } 
-    get {
-      float ret = AssimpPINVOKE.aiLight_mAngleOuterCone_get(swigCPtr);
-      return ret;
-    } 
-  }
-
-  public aiLight() : this(AssimpPINVOKE.new_aiLight(), true) {
-  }
-
-}