v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #6 from assimp/master 

Update Fork
pull/1350/head
Madrich 2015-06-19 10:41:23 +02:00
parent b6d91ec11a 63ef641ae8
commit 4764956cb4
192 changed files with 1833 additions and 43945 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.travis.yml
View File

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

72
CMakeLists.txt
View File

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

12
CodeConventions.md 100644
View File

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

14
CodeConventions.txt
View File

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

64
cmake-modules/AddGTest.cmake
View File

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

2
code/3DSConverter.cpp
View File

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

1
code/3DSExporter.cpp
View File

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

12
code/ASEParser.cpp
View File

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

33
code/AssbinLoader.cpp
View File

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

15
code/Assimp.cpp
View File

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

14
code/BaseImporter.cpp
View File

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

193
code/CMakeLists.txt
View File

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

223
code/ColladaExporter.cpp
View File

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

24
code/ColladaExporter.h
View File

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

26
code/ColladaHelper.h
View File

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

11
code/ColladaLoader.cpp
View File

@ -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))+
srcLight->mFalloffAngle);
out->mAngleOuterCone = std::acos(std::pow(0.1f,1.f/srcLight->mFalloffExponent))+
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;

2
code/ColladaLoader.h
View File

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

2
code/ComputeUVMappingProcess.cpp
View File

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

2
code/DeboneProcess.cpp
View File

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

8
code/DefaultLogger.cpp
View File

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

21
code/FBXParser.cpp
View File

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

1
code/FindInvalidDataProcess.cpp
View File

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

2
code/FixNormalsStep.cpp
View File

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

10
code/IFCCurve.cpp
View File

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

18
code/IFCLoader.cpp
View File

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

2
code/IFCProfile.cpp
View File

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

2
code/IRRLoader.cpp
View File

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

6
code/ImproveCacheLocality.cpp
View File

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

2
code/LWOLoader.cpp
View File

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

2
code/LWSLoader.cpp
View File

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

2
code/LimitBoneWeightsProcess.cpp
View File

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

4
code/MD3Loader.cpp
View File

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

4
code/MD5Parser.cpp
View File

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

4
code/MDLLoader.cpp
View File

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

2
code/MS3DLoader.cpp
View File

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

2
code/NFFLoader.cpp
View File

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

2
code/ObjExporter.cpp
View File

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

23
code/ObjFileMtlImporter.cpp
View File

@ -263,16 +263,21 @@ void ObjFileMtlImporter::createMaterial()
}
std::vector<std::string> token;
const unsigned int numToken = tokenize<std::string>( line, token, " " );
std::string name( "" );
if ( numToken == 1 ) {
name = AI_DEFAULT_MATERIAL_NAME;
} else {
name = token[ 1 ];
}
const unsigned int numToken = tokenize<std::string>( line, token, " \t" );
std::string name( "" );
if ( numToken == 1 ) {
name = AI_DEFAULT_MATERIAL_NAME;
} else {
// 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 );
if ( m_pModel->m_MaterialMap.end() == it) {
std::map<std::string, ObjFile::Material*>::iterator it = m_pModel->m_MaterialMap.find( name );
if ( m_pModel->m_MaterialMap.end() == it) {
// New Material created
m_pModel->m_pCurrentMaterial = new ObjFile::Material();
m_pModel->m_pCurrentMaterial->MaterialName.Set( name );

2
code/ObjFileParser.cpp
View File

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

5
code/ObjFileParser.h
View File

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

2
code/OgreImporter.h
View File

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

2
code/OgreMaterial.cpp
View File

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

98
code/OpenGEXImporter.cpp
View File

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

1
code/OpenGEXImporter.h
View File

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

12
code/OptimizeGraph.cpp
View File

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

9
code/OptimizeMeshes.cpp
View File

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

3
code/OptimizeMeshes.h
View File

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

1
code/PlyExporter.cpp
View File

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

1
code/PlyExporter.h
View File

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

12
code/PretransformVertices.cpp
View File

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

4
code/RemoveRedundantMaterials.cpp
View File

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

4
code/RemoveVCProcess.cpp
View File

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

6
code/SMDLoader.cpp
View File

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

22
code/STEPFileReader.cpp
View File

@ -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 = "")
{

3
code/STLExporter.cpp
View File

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

1
code/STLExporter.h
View File

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

10
code/SortByPTypeProcess.cpp
View File

@ -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)",
aiNumMeshesPerPType[0], (configRemoveMeshes & aiPrimitiveType_POINT ? "X" : ""),
aiNumMeshesPerPType[1], (configRemoveMeshes & aiPrimitiveType_LINE ? "X" : ""),
aiNumMeshesPerPType[2], (configRemoveMeshes & aiPrimitiveType_TRIANGLE ? "X" : ""),
aiNumMeshesPerPType[3], (configRemoveMeshes & aiPrimitiveType_POLYGON ? "X" : ""));
::sprintf(buffer,"Points: %u%s, Lines: %u%s, Triangles: %u%s, Polygons: %u%s (Meshes, X = removed)",
aiNumMeshesPerPType[0], ((configRemoveMeshes & aiPrimitiveType_POINT) ? "X" : ""),
aiNumMeshesPerPType[1], ((configRemoveMeshes & aiPrimitiveType_LINE) ? "X" : ""),
aiNumMeshesPerPType[2], ((configRemoveMeshes & aiPrimitiveType_TRIANGLE) ? "X" : ""),
aiNumMeshesPerPType[3], ((configRemoveMeshes & aiPrimitiveType_POLYGON) ? "X" : ""));
DefaultLogger::get()->info(buffer);
DefaultLogger::get()->debug("SortByPTypeProcess finished");
}

24
code/StepExporter.cpp
View File

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

3
code/TextureTransform.cpp
View File

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

2
code/UnrealLoader.cpp
View File

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

6
code/ValidateDataStructure.cpp
View File

@ -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 + (len=*reinterpret_cast<uint32_t*>(prop->mData)) + 1) {
if (prop->mDataLength < 5 || prop->mDataLength < 4 + (*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));

15
code/XFileExporter.cpp
View File

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

17
code/assbin_chunks.h
View File

@ -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
UV coordinates are written to disk. If mNumUVComponents[0] is 1, the
corresponding mTextureCoords array consists of mNumTextureCoords*1
single floats.
data.
-> the on-disk format always uses 3 floats to write UV coordinates.
If mNumUVComponents[0] is 1, the corresponding mTextureCoords array
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

61
contrib/openddlparser/code/Value.cpp
View File

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

80
contrib/openddlparser/include/openddlparser/DDLNode.h
View File

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

82
contrib/openddlparser/include/openddlparser/OpenDDLCommon.h
View File

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

4
contrib/openddlparser/include/openddlparser/OpenDDLParser.h
View File

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

9
contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h
View File

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

50
contrib/openddlparser/include/openddlparser/Value.h
View File

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

9
include/assimp/Exporter.hpp
View File

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

14
include/assimp/cimport.h
View File

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

6
include/assimp/defs.h
View File

@ -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_RAD_TO_DEG(x) (x*57.2957795f)
#define AI_DEG_TO_RAD(x) ((x)*0.0174532925f)
#define AI_RAD_TO_DEG(x) ((x)*57.2957795f)
/* Support for big-endian builds */
#if defined(__BYTE_ORDER__)

2
include/assimp/importerdesc.h
View File

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

275
port/Assimp.NET/Assimp.NET.sln
View File

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

237
port/Assimp.NET/Assimp.NET/Assimp.NET.vcproj
View File

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

567
port/Assimp.NET/Assimp.NET/AssimpSwigPort.i
View File

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

21287
port/Assimp.NET/Assimp.NET/AssimpSwigPort_wrap.cxx
View File

File diff suppressed because it is too large Load Diff

176
port/Assimp.NET/Assimp.NET_CS/Assimp.NET_CS.csproj
View File

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

137
port/Assimp.NET/Assimp.NET_CS/Assimp.cs
View File

@ -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();
}

3976
port/Assimp.NET/Assimp.NET_CS/AssimpPINVOKE.cs
View File

File diff suppressed because it is too large Load Diff

346
port/Assimp.NET/Assimp.NET_CS/FloatVector.cs
View File

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

206
port/Assimp.NET/Assimp.NET_CS/Importer.cs
View File

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

53
port/Assimp.NET/Assimp.NET_CS/ProgressHandler.cs
View File

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

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_Assimp__BaseImporter.cs
View File

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

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_Assimp__ImporterPimpl.cs
View File

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

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_aiImporterDesc.cs
View File

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

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_float.cs
View File

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

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_std__string.cs
View File

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

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_void.cs
View File

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

346
port/Assimp.NET/Assimp.NET_CS/UintVector.cs
View File

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

15
port/Assimp.NET/Assimp.NET_CS/aiAnimBehaviour.cs
View File

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

92
port/Assimp.NET/Assimp.NET_CS/aiAnimMesh.cs
View File

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

348
port/Assimp.NET/Assimp.NET_CS/aiAnimMeshVector.cs
View File

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

112
port/Assimp.NET/Assimp.NET_CS/aiAnimation.cs
View File

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

348
port/Assimp.NET/Assimp.NET_CS/aiAnimationVector.cs
View File

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

13
port/Assimp.NET/Assimp.NET_CS/aiBlendMode.cs
View File

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

88
port/Assimp.NET/Assimp.NET_CS/aiBone.cs
View File

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

348
port/Assimp.NET/Assimp.NET_CS/aiBoneVector.cs
View File

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

135
port/Assimp.NET/Assimp.NET_CS/aiCamera.cs
View File

@ -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();
}
}

348
port/Assimp.NET/Assimp.NET_CS/aiCameraVector.cs
View File

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

Some files were not shown because too many files have changed in this diff Show More