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

Merge pull request #2708 from assimp/cleanup_headers 

Cleanup headers
pull/2690/head
Kim Kulling 2019-10-11 20:34:54 +02:00 committed by GitHub
parent 14f8877a2c 3c3549a07a
commit 799fd74714
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
81 changed files with 805 additions and 628 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
code/3DS/3DSLoader.cpp
View File

@ -50,9 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef ASSIMP_BUILD_NO_3DS_IMPORTER #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
// internal headers
#include "3DSLoader.h" #include "3DSLoader.h"
#include <assimp/Macros.h>
#include <assimp/IOSystem.hpp> #include <assimp/IOSystem.hpp>
#include <assimp/scene.h> #include <assimp/scene.h>
#include <assimp/DefaultLogger.hpp> #include <assimp/DefaultLogger.hpp>

3
code/CMakeLists.txt
View File

@ -137,7 +137,6 @@ SET( PUBLIC_HEADERS
${HEADER_PATH}/irrXMLWrapper.h ${HEADER_PATH}/irrXMLWrapper.h
${HEADER_PATH}/BlobIOSystem.h ${HEADER_PATH}/BlobIOSystem.h
${HEADER_PATH}/MathFunctions.h ${HEADER_PATH}/MathFunctions.h
${HEADER_PATH}/Macros.h
${HEADER_PATH}/Exceptional.h ${HEADER_PATH}/Exceptional.h
${HEADER_PATH}/ByteSwapper.h ${HEADER_PATH}/ByteSwapper.h
) )
@ -1059,6 +1058,8 @@ MESSAGE(STATUS "Disabled importer formats:${ASSIMP_IMPORTERS_DISABLED}")
MESSAGE(STATUS "Enabled exporter formats:${ASSIMP_EXPORTERS_ENABLED}") MESSAGE(STATUS "Enabled exporter formats:${ASSIMP_EXPORTERS_ENABLED}")
MESSAGE(STATUS "Disabled exporter formats:${ASSIMP_EXPORTERS_DISABLED}") MESSAGE(STATUS "Disabled exporter formats:${ASSIMP_EXPORTERS_DISABLED}")
SOURCE_GROUP( include\\assimp FILES ${PUBLIC_HEADERS} )
SET( assimp_src SET( assimp_src
# Assimp Files # Assimp Files
${Core_SRCS} ${Core_SRCS}

1
code/Irr/IRRMeshLoader.cpp
View File

@ -57,7 +57,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/material.h> #include <assimp/material.h>
#include <assimp/scene.h> #include <assimp/scene.h>
#include <assimp/importerdesc.h> #include <assimp/importerdesc.h>
#include <assimp/Macros.h>
using namespace Assimp; using namespace Assimp;
using namespace irr; using namespace irr;

1
code/MDL/MDLLoader.cpp
View File

@ -52,7 +52,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "MDL/MDLDefaultColorMap.h" #include "MDL/MDLDefaultColorMap.h"
#include "MD2/MD2FileData.h" #include "MD2/MD2FileData.h"
#include <assimp/Macros.h>
#include <assimp/qnan.h> #include <assimp/qnan.h>
#include <assimp/StringUtils.h> #include <assimp/StringUtils.h>
#include <assimp/Importer.hpp> #include <assimp/Importer.hpp>

1
code/Material/MaterialSystem.cpp
View File

@ -51,7 +51,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/types.h> #include <assimp/types.h>
#include <assimp/material.h> #include <assimp/material.h>
#include <assimp/DefaultLogger.hpp> #include <assimp/DefaultLogger.hpp>
#include <assimp/Macros.h>
using namespace Assimp; using namespace Assimp;

1
code/Ply/PlyLoader.cpp
View File

@ -49,7 +49,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// internal headers // internal headers
#include "PlyLoader.h" #include "PlyLoader.h"
#include <assimp/IOStreamBuffer.h> #include <assimp/IOStreamBuffer.h>
#include <assimp/Macros.h>
#include <memory> #include <memory>
#include <assimp/IOSystem.hpp> #include <assimp/IOSystem.hpp>
#include <assimp/scene.h> #include <assimp/scene.h>

1
code/PostProcessing/FindInvalidDataProcess.cpp
View File

@ -52,7 +52,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "FindInvalidDataProcess.h" #include "FindInvalidDataProcess.h"
#include "ProcessHelper.h" #include "ProcessHelper.h"
#include <assimp/Macros.h>
#include <assimp/Exceptional.h> #include <assimp/Exceptional.h>
#include <assimp/qnan.h> #include <assimp/qnan.h>

5
include/assimp/BaseImporter.h
View File

@ -41,9 +41,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
/** @file Definition of the base class for all importer worker classes. */ /** @file Definition of the base class for all importer worker classes. */
#pragma once
#ifndef INCLUDED_AI_BASEIMPORTER_H #ifndef INCLUDED_AI_BASEIMPORTER_H
#define INCLUDED_AI_BASEIMPORTER_H #define INCLUDED_AI_BASEIMPORTER_H
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include "Exceptional.h" #include "Exceptional.h"
#include <vector> #include <vector>

6
include/assimp/Bitmap.h
View File

@ -46,10 +46,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* Used for file formats which embed their textures into the model file. * Used for file formats which embed their textures into the model file.
*/ */
#pragma once
#ifndef AI_BITMAP_H_INC #ifndef AI_BITMAP_H_INC
#define AI_BITMAP_H_INC #define AI_BITMAP_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include "defs.h" #include "defs.h"
#include <stdint.h> #include <stdint.h>
#include <cstddef> #include <cstddef>

5
include/assimp/ByteSwapper.h
View File

@ -42,9 +42,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file Helper class tp perform various byte oder swappings /** @file Helper class tp perform various byte oder swappings
(e.g. little to big endian) */ (e.g. little to big endian) */
#pragma once
#ifndef AI_BYTESWAPPER_H_INC #ifndef AI_BYTESWAPPER_H_INC
#define AI_BYTESWAPPER_H_INC #define AI_BYTESWAPPER_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/ai_assert.h> #include <assimp/ai_assert.h>
#include <assimp/types.h> #include <assimp/types.h>
#include <stdint.h> #include <stdint.h>

14
include/assimp/CreateAnimMesh.h
View File

@ -43,16 +43,26 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file CreateAnimMesh.h /** @file CreateAnimMesh.h
* Create AnimMesh from Mesh * Create AnimMesh from Mesh
*/ */
#pragma once
#ifndef INCLUDED_AI_CREATE_ANIM_MESH_H #ifndef INCLUDED_AI_CREATE_ANIM_MESH_H
#define INCLUDED_AI_CREATE_ANIM_MESH_H #define INCLUDED_AI_CREATE_ANIM_MESH_H
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/mesh.h> #include <assimp/mesh.h>
namespace Assimp { namespace Assimp {
/** Create aiAnimMesh from aiMesh. */ /**
* Create aiAnimMesh from aiMesh.
* @param mesh The input mesh to create an animated mesh from.
* @return The new created animated mesh.
*/
ASSIMP_API aiAnimMesh *aiCreateAnimMesh(const aiMesh *mesh); ASSIMP_API aiAnimMesh *aiCreateAnimMesh(const aiMesh *mesh);
} // end of namespace Assimp } // end of namespace Assimp
#endif // INCLUDED_AI_CREATE_ANIM_MESH_H #endif // INCLUDED_AI_CREATE_ANIM_MESH_H

19
include/assimp/DefaultIOStream.h
View File

@ -41,15 +41,20 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
/** @file Default file I/O using fXXX()-family of functions */ /** @file Default file I/O using fXXX()-family of functions */
#pragma once
#ifndef AI_DEFAULTIOSTREAM_H_INC #ifndef AI_DEFAULTIOSTREAM_H_INC
#define AI_DEFAULTIOSTREAM_H_INC #define AI_DEFAULTIOSTREAM_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <stdio.h> #include <stdio.h>
#include <assimp/IOStream.hpp> #include <assimp/IOStream.hpp>
#include <assimp/importerdesc.h> #include <assimp/importerdesc.h>
#include <assimp/Defines.h> #include <assimp/Defines.h>
namespace Assimp { namespace Assimp {
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
//! @class DefaultIOStream //! @class DefaultIOStream
@ -57,8 +62,7 @@ namespace Assimp {
//! @note An instance of this class can exist without a valid file handle //! @note An instance of this class can exist without a valid file handle
//! attached to it. All calls fail, but the instance can nevertheless be //! attached to it. All calls fail, but the instance can nevertheless be
//! used with no restrictions. //! used with no restrictions.
class ASSIMP_API DefaultIOStream : public IOStream class ASSIMP_API DefaultIOStream : public IOStream {
{
friend class DefaultIOSystem; friend class DefaultIOSystem;
#if __ANDROID__ #if __ANDROID__
# if __ANDROID_API__ > 9 # if __ANDROID_API__ > 9
@ -82,7 +86,6 @@ public:
size_t pSize, size_t pSize,
size_t pCount); size_t pCount);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/// Write to stream /// Write to stream
size_t Write(const void* pvBuffer, size_t Write(const void* pvBuffer,
@ -107,16 +110,13 @@ public:
void Flush(); void Flush();
private: private:
// File data-structure, using clib
FILE* mFile; FILE* mFile;
// Filename
std::string mFilename; std::string mFilename;
// Cached file size
mutable size_t mCachedSize; mutable size_t mCachedSize;
}; };
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline AI_FORCE_INLINE
DefaultIOStream::DefaultIOStream() AI_NO_EXCEPT DefaultIOStream::DefaultIOStream() AI_NO_EXCEPT
: mFile(nullptr) : mFile(nullptr)
, mFilename("") , mFilename("")
@ -125,7 +125,7 @@ DefaultIOStream::DefaultIOStream() AI_NO_EXCEPT
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline AI_FORCE_INLINE
DefaultIOStream::DefaultIOStream (FILE* pFile, const std::string &strFilename) DefaultIOStream::DefaultIOStream (FILE* pFile, const std::string &strFilename)
: mFile(pFile) : mFile(pFile)
, mFilename(strFilename) , mFilename(strFilename)
@ -137,4 +137,3 @@ DefaultIOStream::DefaultIOStream (FILE* pFile, const std::string &strFilename)
} // ns assimp } // ns assimp
#endif //!!AI_DEFAULTIOSTREAM_H_INC #endif //!!AI_DEFAULTIOSTREAM_H_INC

5
include/assimp/DefaultIOSystem.h
View File

@ -41,9 +41,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
/** @file Default implementation of IOSystem using the standard C file functions */ /** @file Default implementation of IOSystem using the standard C file functions */
#pragma once
#ifndef AI_DEFAULTIOSYSTEM_H_INC #ifndef AI_DEFAULTIOSYSTEM_H_INC
#define AI_DEFAULTIOSYSTEM_H_INC #define AI_DEFAULTIOSYSTEM_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/IOSystem.hpp> #include <assimp/IOSystem.hpp>
namespace Assimp { namespace Assimp {

9
include/assimp/Defines.h
View File

@ -38,6 +38,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
#pragma once
#ifndef AI_DEFINES_H_INC
#define AI_DEFINES_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
// We need those constants, workaround for any platforms where nobody defined them yet // We need those constants, workaround for any platforms where nobody defined them yet
#if (!defined SIZE_MAX) #if (!defined SIZE_MAX)
# define SIZE_MAX (~((size_t)0)) # define SIZE_MAX (~((size_t)0))
@ -47,3 +55,4 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# define UINT_MAX (~((unsigned int)0)) # define UINT_MAX (~((unsigned int)0))
#endif #endif
#endif // AI_DEINES_H_INC

23
include/assimp/Exceptional.h
View File

@ -38,11 +38,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
#ifndef INCLUDED_EXCEPTIONAL_H #pragma once
#define INCLUDED_EXCEPTIONAL_H #ifndef AI_INCLUDED_EXCEPTIONAL_H
#define AI_INCLUDED_EXCEPTIONAL_H
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <stdexcept> #include <stdexcept>
#include <assimp/DefaultIOStream.h> #include <assimp/DefaultIOStream.h>
using std::runtime_error; using std::runtime_error;
#ifdef _MSC_VER #ifdef _MSC_VER
@ -53,17 +59,14 @@ using std::runtime_error;
/** FOR IMPORTER PLUGINS ONLY: Simple exception class to be thrown if an /** FOR IMPORTER PLUGINS ONLY: Simple exception class to be thrown if an
* unrecoverable error occurs while importing. Loading APIs return * unrecoverable error occurs while importing. Loading APIs return
* NULL instead of a valid aiScene then. */ * NULL instead of a valid aiScene then. */
class DeadlyImportError class DeadlyImportError : public runtime_error {
: public runtime_error
{
public: public:
/** Constructor with arguments */ /** Constructor with arguments */
explicit DeadlyImportError( const std::string& errorText) explicit DeadlyImportError( const std::string& errorText)
: runtime_error(errorText) : runtime_error(errorText) {
{ // empty
} }
private:
}; };
typedef DeadlyImportError DeadlyExportError; typedef DeadlyImportError DeadlyExportError;
@ -84,7 +87,7 @@ struct ExceptionSwallower {
template <typename T> template <typename T>
struct ExceptionSwallower<T*> { struct ExceptionSwallower<T*> {
T* operator ()() const { T* operator ()() const {
return NULL; return nullptr;
} }
}; };
@ -122,4 +125,4 @@ struct ExceptionSwallower<void> {
}\ }\
} }
#endif // INCLUDED_EXCEPTIONAL_H #endif // AI_INCLUDED_EXCEPTIONAL_H

4
include/assimp/Exporter.hpp
View File

@ -48,6 +48,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_EXPORT_HPP_INC #ifndef AI_EXPORT_HPP_INC
#define AI_EXPORT_HPP_INC #define AI_EXPORT_HPP_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#ifndef ASSIMP_BUILD_NO_EXPORT #ifndef ASSIMP_BUILD_NO_EXPORT
#include "cexport.h" #include "cexport.h"

7
include/assimp/GenericProperty.h
View File

@ -40,12 +40,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
#pragma once
#ifndef AI_GENERIC_PROPERTY_H_INCLUDED #ifndef AI_GENERIC_PROPERTY_H_INCLUDED
#define AI_GENERIC_PROPERTY_H_INCLUDED #define AI_GENERIC_PROPERTY_H_INCLUDED
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/Importer.hpp> #include <assimp/Importer.hpp>
#include <assimp/ai_assert.h> #include <assimp/ai_assert.h>
#include "Hash.h" #include <assimp/Hash.h>
#include <map> #include <map>

6
include/assimp/Hash.h
View File

@ -39,10 +39,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
#pragma once
#ifndef AI_HASH_H_INCLUDED #ifndef AI_HASH_H_INCLUDED
#define AI_HASH_H_INCLUDED #define AI_HASH_H_INCLUDED
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>

12
include/assimp/IOStream.hpp
View File

@ -48,14 +48,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_IOSTREAM_H_INC #ifndef AI_IOSTREAM_H_INC
#define AI_IOSTREAM_H_INC #define AI_IOSTREAM_H_INC
#include "types.h" #ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/types.h>
#ifndef __cplusplus #ifndef __cplusplus
# error This header requires C++ to be used. aiFileIO.h is the \ # error This header requires C++ to be used. aiFileIO.h is the \
corresponding C interface. corresponding C interface.
#endif #endif
namespace Assimp { namespace Assimp {
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
/** @brief CPP-API: Class to handle file I/O for C++ /** @brief CPP-API: Class to handle file I/O for C++
@ -125,13 +129,13 @@ public:
}; //! class IOStream }; //! class IOStream
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline AI_FORCE_INLINE
IOStream::IOStream() AI_NO_EXCEPT { IOStream::IOStream() AI_NO_EXCEPT {
// empty // empty
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline AI_FORCE_INLINE
IOStream::~IOStream() { IOStream::~IOStream() {
// empty // empty
} }

43
include/assimp/IOStreamBuffer.h
View File

@ -1,5 +1,3 @@
#pragma once
/* /*
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
---------------------------------------------------------------------- ----------------------------------------------------------------------
@ -42,10 +40,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
#pragma once
#ifndef AI_IOSTREAMBUFFER_H_INC
#define AI_IOSTREAMBUFFER_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/types.h> #include <assimp/types.h>
#include <assimp/IOStream.hpp> #include <assimp/IOStream.hpp>
#include <assimp/ParsingUtils.h>
#include "ParsingUtils.h"
#include <vector> #include <vector>
@ -124,7 +129,7 @@ private:
}; };
template<class T> template<class T>
inline AI_FORCE_INLINE
IOStreamBuffer<T>::IOStreamBuffer( size_t cache ) IOStreamBuffer<T>::IOStreamBuffer( size_t cache )
: m_stream( nullptr ) : m_stream( nullptr )
, m_filesize( 0 ) , m_filesize( 0 )
@ -138,13 +143,13 @@ IOStreamBuffer<T>::IOStreamBuffer( size_t cache )
} }
template<class T> template<class T>
inline AI_FORCE_INLINE
IOStreamBuffer<T>::~IOStreamBuffer() { IOStreamBuffer<T>::~IOStreamBuffer() {
// empty // empty
} }
template<class T> template<class T>
inline AI_FORCE_INLINE
bool IOStreamBuffer<T>::open( IOStream *stream ) { bool IOStreamBuffer<T>::open( IOStream *stream ) {
// file still opened! // file still opened!
if ( nullptr != m_stream ) { if ( nullptr != m_stream ) {
@ -174,7 +179,7 @@ bool IOStreamBuffer<T>::open( IOStream *stream ) {
} }
template<class T> template<class T>
inline AI_FORCE_INLINE
bool IOStreamBuffer<T>::close() { bool IOStreamBuffer<T>::close() {
if ( nullptr == m_stream ) { if ( nullptr == m_stream ) {
return false; return false;
@ -192,19 +197,19 @@ bool IOStreamBuffer<T>::close() {
} }
template<class T> template<class T>
inline AI_FORCE_INLINE
size_t IOStreamBuffer<T>::size() const { size_t IOStreamBuffer<T>::size() const {
return m_filesize; return m_filesize;
} }
template<class T> template<class T>
inline AI_FORCE_INLINE
size_t IOStreamBuffer<T>::cacheSize() const { size_t IOStreamBuffer<T>::cacheSize() const {
return m_cacheSize; return m_cacheSize;
} }
template<class T> template<class T>
inline AI_FORCE_INLINE
bool IOStreamBuffer<T>::readNextBlock() { bool IOStreamBuffer<T>::readNextBlock() {
m_stream->Seek( m_filePos, aiOrigin_SET ); m_stream->Seek( m_filePos, aiOrigin_SET );
size_t readLen = m_stream->Read( &m_cache[ 0 ], sizeof( T ), m_cacheSize ); size_t readLen = m_stream->Read( &m_cache[ 0 ], sizeof( T ), m_cacheSize );
@ -222,25 +227,25 @@ bool IOStreamBuffer<T>::readNextBlock() {
} }
template<class T> template<class T>
inline AI_FORCE_INLINE
size_t IOStreamBuffer<T>::getNumBlocks() const { size_t IOStreamBuffer<T>::getNumBlocks() const {
return m_numBlocks; return m_numBlocks;
} }
template<class T> template<class T>
inline AI_FORCE_INLINE
size_t IOStreamBuffer<T>::getCurrentBlockIndex() const { size_t IOStreamBuffer<T>::getCurrentBlockIndex() const {
return m_blockIdx; return m_blockIdx;
} }
template<class T> template<class T>
inline AI_FORCE_INLINE
size_t IOStreamBuffer<T>::getFilePos() const { size_t IOStreamBuffer<T>::getFilePos() const {
return m_filePos; return m_filePos;
} }
template<class T> template<class T>
inline AI_FORCE_INLINE
bool IOStreamBuffer<T>::getNextDataLine( std::vector<T> &buffer, T continuationToken ) { bool IOStreamBuffer<T>::getNextDataLine( std::vector<T> &buffer, T continuationToken ) {
buffer.resize( m_cacheSize ); buffer.resize( m_cacheSize );
if ( m_cachePos >= m_cacheSize || 0 == m_filePos ) { if ( m_cachePos >= m_cacheSize || 0 == m_filePos ) {
@ -289,13 +294,13 @@ bool IOStreamBuffer<T>::getNextDataLine( std::vector<T> &buffer, T continuationT
return true; return true;
} }
static inline static AI_FORCE_INLINE
bool isEndOfCache( size_t pos, size_t cacheSize ) { bool isEndOfCache( size_t pos, size_t cacheSize ) {
return ( pos == cacheSize ); return ( pos == cacheSize );
} }
template<class T> template<class T>
inline AI_FORCE_INLINE
bool IOStreamBuffer<T>::getNextLine(std::vector<T> &buffer) { bool IOStreamBuffer<T>::getNextLine(std::vector<T> &buffer) {
buffer.resize(m_cacheSize); buffer.resize(m_cacheSize);
if ( isEndOfCache( m_cachePos, m_cacheSize ) || 0 == m_filePos) { if ( isEndOfCache( m_cachePos, m_cacheSize ) || 0 == m_filePos) {
@ -335,7 +340,7 @@ bool IOStreamBuffer<T>::getNextLine(std::vector<T> &buffer) {
} }
template<class T> template<class T>
inline AI_FORCE_INLINE
bool IOStreamBuffer<T>::getNextBlock( std::vector<T> &buffer) { bool IOStreamBuffer<T>::getNextBlock( std::vector<T> &buffer) {
// Return the last block-value if getNextLine was used before // Return the last block-value if getNextLine was used before
if ( 0 != m_cachePos ) { if ( 0 != m_cachePos ) {
@ -353,3 +358,5 @@ bool IOStreamBuffer<T>::getNextBlock( std::vector<T> &buffer) {
} }
} // !ns Assimp } // !ns Assimp
#endif // AI_IOSTREAMBUFFER_H_INC

4
include/assimp/IOSystem.hpp
View File

@ -50,6 +50,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_IOSYSTEM_H_INC #ifndef AI_IOSYSTEM_H_INC
#define AI_IOSYSTEM_H_INC #define AI_IOSYSTEM_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#ifndef __cplusplus #ifndef __cplusplus
# error This header requires C++ to be used. aiFileIO.h is the \ # error This header requires C++ to be used. aiFileIO.h is the \
corresponding C interface. corresponding C interface.

4
include/assimp/Importer.hpp
View File

@ -48,6 +48,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_ASSIMP_HPP_INC #ifndef AI_ASSIMP_HPP_INC
#define AI_ASSIMP_HPP_INC #define AI_ASSIMP_HPP_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#ifndef __cplusplus #ifndef __cplusplus
# error This header requires C++ to be used. Use assimp.h for plain C. # error This header requires C++ to be used. Use assimp.h for plain C.
#endif // __cplusplus #endif // __cplusplus

36
include/assimp/LineSplitter.h
View File

@ -48,9 +48,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef INCLUDED_LINE_SPLITTER_H #ifndef INCLUDED_LINE_SPLITTER_H
#define INCLUDED_LINE_SPLITTER_H #define INCLUDED_LINE_SPLITTER_H
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <stdexcept> #include <stdexcept>
#include "StreamReader.h" #include <assimp/StreamReader.h>
#include "ParsingUtils.h" #include <assimp/ParsingUtils.h>
namespace Assimp { namespace Assimp {
@ -140,7 +144,7 @@ private:
bool mSwallow, mSkip_empty_lines, mTrim; bool mSwallow, mSkip_empty_lines, mTrim;
}; };
inline AI_FORCE_INLINE
LineSplitter::LineSplitter(StreamReaderLE& stream, bool skip_empty_lines, bool trim ) LineSplitter::LineSplitter(StreamReaderLE& stream, bool skip_empty_lines, bool trim )
: mIdx(0) : mIdx(0)
, mCur() , mCur()
@ -153,12 +157,12 @@ LineSplitter::LineSplitter(StreamReaderLE& stream, bool skip_empty_lines, bool t
mIdx = 0; mIdx = 0;
} }
inline AI_FORCE_INLINE
LineSplitter::~LineSplitter() { LineSplitter::~LineSplitter() {
// empty // empty
} }
inline AI_FORCE_INLINE
LineSplitter& LineSplitter::operator++() { LineSplitter& LineSplitter::operator++() {
if (mSwallow) { if (mSwallow) {
mSwallow = false; mSwallow = false;
@ -199,12 +203,12 @@ LineSplitter& LineSplitter::operator++() {
return *this; return *this;
} }
inline AI_FORCE_INLINE
LineSplitter &LineSplitter::operator++(int) { LineSplitter &LineSplitter::operator++(int) {
return ++(*this); return ++(*this);
} }
inline AI_FORCE_INLINE
const char *LineSplitter::operator[] (size_t idx) const { const char *LineSplitter::operator[] (size_t idx) const {
const char* s = operator->()->c_str(); const char* s = operator->()->c_str();
@ -222,7 +226,7 @@ const char *LineSplitter::operator[] (size_t idx) const {
} }
template <size_t N> template <size_t N>
inline AI_FORCE_INLINE
void LineSplitter::get_tokens(const char* (&tokens)[N]) const { void LineSplitter::get_tokens(const char* (&tokens)[N]) const {
const char* s = operator->()->c_str(); const char* s = operator->()->c_str();
@ -238,44 +242,44 @@ void LineSplitter::get_tokens(const char* (&tokens)[N]) const {
} }
} }
inline AI_FORCE_INLINE
const std::string* LineSplitter::operator -> () const { const std::string* LineSplitter::operator -> () const {
return &mCur; return &mCur;
} }
inline AI_FORCE_INLINE
std::string LineSplitter::operator* () const { std::string LineSplitter::operator* () const {
return mCur; return mCur;
} }
inline AI_FORCE_INLINE
LineSplitter::operator bool() const { LineSplitter::operator bool() const {
return mStream.GetRemainingSize() > 0; return mStream.GetRemainingSize() > 0;
} }
inline AI_FORCE_INLINE
LineSplitter::operator line_idx() const { LineSplitter::operator line_idx() const {
return mIdx; return mIdx;
} }
inline AI_FORCE_INLINE
LineSplitter::line_idx LineSplitter::get_index() const { LineSplitter::line_idx LineSplitter::get_index() const {
return mIdx; return mIdx;
} }
inline AI_FORCE_INLINE
StreamReaderLE &LineSplitter::get_stream() { StreamReaderLE &LineSplitter::get_stream() {
return mStream; return mStream;
} }
inline AI_FORCE_INLINE
bool LineSplitter::match_start(const char* check) { bool LineSplitter::match_start(const char* check) {
const size_t len = ::strlen(check); const size_t len = ::strlen(check);
return len <= mCur.length() && std::equal(check, check + len, mCur.begin()); return len <= mCur.length() && std::equal(check, check + len, mCur.begin());
} }
inline AI_FORCE_INLINE
void LineSplitter::swallow_next_increment() { void LineSplitter::swallow_next_increment() {
mSwallow = true; mSwallow = true;
} }

5
include/assimp/LogAux.h
View File

@ -43,9 +43,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file LogAux.h /** @file LogAux.h
* @brief Common logging usage patterns for importer implementations * @brief Common logging usage patterns for importer implementations
*/ */
#pragma once
#ifndef INCLUDED_AI_LOGAUX_H #ifndef INCLUDED_AI_LOGAUX_H
#define INCLUDED_AI_LOGAUX_H #define INCLUDED_AI_LOGAUX_H
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/TinyFormatter.h> #include <assimp/TinyFormatter.h>
#include <assimp/Exceptional.h> #include <assimp/Exceptional.h>
#include <assimp/DefaultLogger.hpp> #include <assimp/DefaultLogger.hpp>

49
include/assimp/Macros.h
View File

@ -1,49 +0,0 @@
/*
---------------------------------------------------------------------------
Open Asset Import Library (assimp)
---------------------------------------------------------------------------
Copyright (c) 2006-2019, assimp team
All rights reserved.
Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the following
conditions are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the
following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products
derived from this software without specific prior
written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
/* Helper macro to set a pointer to NULL in debug builds
*/
#if (defined ASSIMP_BUILD_DEBUG)
# define AI_DEBUG_INVALIDATE_PTR(x) x = NULL;
#else
# define AI_DEBUG_INVALIDATE_PTR(x)
#endif

4
include/assimp/MathFunctions.h
View File

@ -41,6 +41,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#pragma once #pragma once
#ifdef __GNUC__
# pragma GCC system_header
#endif
/** @file MathFunctions.h /** @file MathFunctions.h
* @brief Implementation of math utility functions. * @brief Implementation of math utility functions.
* *

6
include/assimp/MemoryIOWrapper.h
View File

@ -42,12 +42,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file MemoryIOWrapper.h /** @file MemoryIOWrapper.h
* Handy IOStream/IOSystem implemetation to read directly from a memory buffer */ * Handy IOStream/IOSystem implemetation to read directly from a memory buffer */
#pragma once
#ifndef AI_MEMORYIOSTREAM_H_INC #ifndef AI_MEMORYIOSTREAM_H_INC
#define AI_MEMORYIOSTREAM_H_INC #define AI_MEMORYIOSTREAM_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/IOStream.hpp> #include <assimp/IOStream.hpp>
#include <assimp/IOSystem.hpp> #include <assimp/IOSystem.hpp>
#include <assimp/ai_assert.h> #include <assimp/ai_assert.h>
#include <stdint.h> #include <stdint.h>
namespace Assimp { namespace Assimp {

9
include/assimp/ParsingUtils.h
View File

@ -44,11 +44,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file ParsingUtils.h /** @file ParsingUtils.h
* @brief Defines helper functions for text parsing * @brief Defines helper functions for text parsing
*/ */
#pragma once
#ifndef AI_PARSING_UTILS_H_INC #ifndef AI_PARSING_UTILS_H_INC
#define AI_PARSING_UTILS_H_INC #define AI_PARSING_UTILS_H_INC
#include "StringComparison.h" #ifdef __GNUC__
#include "StringUtils.h" # pragma GCC system_header
#endif
#include <assimp/StringComparison.h>
#include <assimp/StringUtils.h>
#include <assimp/defs.h> #include <assimp/defs.h>
namespace Assimp { namespace Assimp {

14
include/assimp/Profiler.h
View File

@ -43,12 +43,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file Profiler.h /** @file Profiler.h
* @brief Utility to measure the respective runtime of each import step * @brief Utility to measure the respective runtime of each import step
*/ */
#ifndef INCLUDED_PROFILER_H #pragma once
#define INCLUDED_PROFILER_H #ifndef AI_INCLUDED_PROFILER_H
#define AI_INCLUDED_PROFILER_H
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <chrono> #include <chrono>
#include <assimp/DefaultLogger.hpp> #include <assimp/DefaultLogger.hpp>
#include "TinyFormatter.h" #include <assimp/TinyFormatter.h>
#include <map> #include <map>
@ -67,7 +72,6 @@ public:
// empty // empty
} }
public:
/** Start a named timer */ /** Start a named timer */
void BeginRegion(const std::string& region) { void BeginRegion(const std::string& region) {
@ -95,5 +99,5 @@ private:
} }
} }
#endif #endif // AI_INCLUDED_PROFILER_H

8
include/assimp/ProgressHandler.hpp
View File

@ -47,9 +47,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_PROGRESSHANDLER_H_INC #ifndef AI_PROGRESSHANDLER_H_INC
#define AI_PROGRESSHANDLER_H_INC #define AI_PROGRESSHANDLER_H_INC
#include "types.h" #ifdef __GNUC__
# pragma GCC system_header
#endif
namespace Assimp { #include <assimp/types.h>
namespace Assimp {
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
/** @brief CPP-API: Abstract interface for custom progress report receivers. /** @brief CPP-API: Abstract interface for custom progress report receivers.

8
include/assimp/RemoveComments.h
View File

@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2019, assimp team Copyright (c) 2006-2019, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -43,9 +42,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file Declares a helper class, "CommentRemover", which can be /** @file Declares a helper class, "CommentRemover", which can be
* used to remove comments (single and multi line) from a text file. * used to remove comments (single and multi line) from a text file.
*/ */
#pragma once
#ifndef AI_REMOVE_COMMENTS_H_INC #ifndef AI_REMOVE_COMMENTS_H_INC
#define AI_REMOVE_COMMENTS_H_INC #define AI_REMOVE_COMMENTS_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/defs.h> #include <assimp/defs.h>
@ -58,8 +61,7 @@ namespace Assimp {
* to those in C or C++ so this code has been moved to a separate * to those in C or C++ so this code has been moved to a separate
* module. * module.
*/ */
class ASSIMP_API CommentRemover class ASSIMP_API CommentRemover {
{
// class cannot be instanced // class cannot be instanced
CommentRemover() {} CommentRemover() {}

5
include/assimp/SGSpatialSort.h
View File

@ -42,9 +42,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** Small helper classes to optimize finding vertices close to a given location /** Small helper classes to optimize finding vertices close to a given location
*/ */
#pragma once
#ifndef AI_D3DSSPATIALSORT_H_INC #ifndef AI_D3DSSPATIALSORT_H_INC
#define AI_D3DSSPATIALSORT_H_INC #define AI_D3DSSPATIALSORT_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/types.h> #include <assimp/types.h>
#include <vector> #include <vector>
#include <stdint.h> #include <stdint.h>

7
include/assimp/SceneCombiner.h
View File

@ -43,17 +43,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file Declares a helper class, "SceneCombiner" providing various /** @file Declares a helper class, "SceneCombiner" providing various
* utilities to merge scenes. * utilities to merge scenes.
*/ */
#pragma once
#ifndef AI_SCENE_COMBINER_H_INC #ifndef AI_SCENE_COMBINER_H_INC
#define AI_SCENE_COMBINER_H_INC #define AI_SCENE_COMBINER_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/ai_assert.h> #include <assimp/ai_assert.h>
#include <assimp/types.h> #include <assimp/types.h>
#include <assimp/Defines.h> #include <assimp/Defines.h>
#include <stddef.h> #include <stddef.h>
#include <set> #include <set>
#include <list> #include <list>
#include <stdint.h> #include <stdint.h>
#include <vector> #include <vector>
struct aiScene; struct aiScene;

5
include/assimp/SkeletonMeshBuilder.h
View File

@ -47,9 +47,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* for animation skeletons. * for animation skeletons.
*/ */
#pragma once
#ifndef AI_SKELETONMESHBUILDER_H_INC #ifndef AI_SKELETONMESHBUILDER_H_INC
#define AI_SKELETONMESHBUILDER_H_INC #define AI_SKELETONMESHBUILDER_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <vector> #include <vector>
#include <assimp/mesh.h> #include <assimp/mesh.h>

6
include/assimp/SmoothingGroups.h
View File

@ -43,10 +43,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file Defines the helper data structures for importing 3DS files. /** @file Defines the helper data structures for importing 3DS files.
http://www.jalix.org/ressources/graphics/3DS/_unofficials/3ds-unofficial.txt */ http://www.jalix.org/ressources/graphics/3DS/_unofficials/3ds-unofficial.txt */
#pragma once
#ifndef AI_SMOOTHINGGROUPS_H_INC #ifndef AI_SMOOTHINGGROUPS_H_INC
#define AI_SMOOTHINGGROUPS_H_INC #define AI_SMOOTHINGGROUPS_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/vector3.h> #include <assimp/vector3.h>
#include <stdint.h> #include <stdint.h>
#include <vector> #include <vector>

7
include/assimp/SmoothingGroups.inl
View File

@ -41,13 +41,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file Generation of normal vectors basing on smoothing groups */ /** @file Generation of normal vectors basing on smoothing groups */
#pragma once
#ifndef AI_SMOOTHINGGROUPS_INL_INCLUDED #ifndef AI_SMOOTHINGGROUPS_INL_INCLUDED
#define AI_SMOOTHINGGROUPS_INL_INCLUDED #define AI_SMOOTHINGGROUPS_INL_INCLUDED
// internal headers #ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/SGSpatialSort.h> #include <assimp/SGSpatialSort.h>
// CRT header
#include <algorithm> #include <algorithm>
using namespace Assimp; using namespace Assimp;

5
include/assimp/SpatialSort.h
View File

@ -41,9 +41,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
/** Small helper classes to optimise finding vertizes close to a given location */ /** Small helper classes to optimise finding vertizes close to a given location */
#pragma once
#ifndef AI_SPATIALSORT_H_INC #ifndef AI_SPATIALSORT_H_INC
#define AI_SPATIALSORT_H_INC #define AI_SPATIALSORT_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <vector> #include <vector>
#include <assimp/types.h> #include <assimp/types.h>

7
include/assimp/StandardShapes.h
View File

@ -41,11 +41,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
/** @file Declares a helper class, "StandardShapes" which generates /** @file Declares a helper class, "StandardShapes" which generates
* vertices for standard shapes, such as cylnders, cones, spheres .. * vertices for standard shapes, such as cylinders, cones, spheres ..
*/ */
#pragma once
#ifndef AI_STANDARD_SHAPES_H_INC #ifndef AI_STANDARD_SHAPES_H_INC
#define AI_STANDARD_SHAPES_H_INC #define AI_STANDARD_SHAPES_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/vector3.h> #include <assimp/vector3.h>
#include <vector> #include <vector>

10
include/assimp/StreamReader.h
View File

@ -44,15 +44,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file Defines the StreamReader class which reads data from /** @file Defines the StreamReader class which reads data from
* a binary stream with a well-defined endianness. * a binary stream with a well-defined endianness.
*/ */
#pragma once
#ifndef AI_STREAMREADER_H_INCLUDED #ifndef AI_STREAMREADER_H_INCLUDED
#define AI_STREAMREADER_H_INCLUDED #define AI_STREAMREADER_H_INCLUDED
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/IOStream.hpp> #include <assimp/IOStream.hpp>
#include <assimp/Defines.h> #include <assimp/Defines.h>
#include <assimp/ByteSwapper.h>
#include <assimp/Exceptional.h>
#include "ByteSwapper.h"
#include "Exceptional.h"
#include <memory> #include <memory>
namespace Assimp { namespace Assimp {

8
include/assimp/StreamWriter.h
View File

@ -43,11 +43,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file Defines the StreamWriter class which writes data to /** @file Defines the StreamWriter class which writes data to
* a binary stream with a well-defined endianness. */ * a binary stream with a well-defined endianness. */
#pragma once
#ifndef AI_STREAMWRITER_H_INCLUDED #ifndef AI_STREAMWRITER_H_INCLUDED
#define AI_STREAMWRITER_H_INCLUDED #define AI_STREAMWRITER_H_INCLUDED
#include "ByteSwapper.h" #ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/ByteSwapper.h>
#include <assimp/IOStream.hpp> #include <assimp/IOStream.hpp>
#include <memory> #include <memory>

7
include/assimp/StringComparison.h
View File

@ -49,12 +49,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
These functions are not consistently available on all platforms, These functions are not consistently available on all platforms,
or the provided implementations behave too differently. or the provided implementations behave too differently.
*/ */
#pragma once
#ifndef INCLUDED_AI_STRING_WORKERS_H #ifndef INCLUDED_AI_STRING_WORKERS_H
#define INCLUDED_AI_STRING_WORKERS_H #define INCLUDED_AI_STRING_WORKERS_H
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/ai_assert.h> #include <assimp/ai_assert.h>
#include <assimp/defs.h> #include <assimp/defs.h>
#include "StringComparison.h" #include <assimp/StringComparison.h>
#include <string.h> #include <string.h>
#include <stdint.h> #include <stdint.h>

5
include/assimp/StringUtils.h
View File

@ -39,9 +39,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
#pragma once
#ifndef INCLUDED_AI_STRINGUTILS_H #ifndef INCLUDED_AI_STRINGUTILS_H
#define INCLUDED_AI_STRINGUTILS_H #define INCLUDED_AI_STRINGUTILS_H
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/defs.h> #include <assimp/defs.h>
#include <sstream> #include <sstream>

5
include/assimp/Subdivision.h
View File

@ -45,7 +45,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_SUBDISIVION_H_INC #ifndef AI_SUBDISIVION_H_INC
#define AI_SUBDISIVION_H_INC #define AI_SUBDISIVION_H_INC
#include <cstddef> #ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/types.h> #include <assimp/types.h>
struct aiMesh; struct aiMesh;

32
include/assimp/TinyFormatter.h
View File

@ -45,9 +45,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* to get rid of the boost::format dependency. Much slinker, * to get rid of the boost::format dependency. Much slinker,
* basically just extends stringstream. * basically just extends stringstream.
*/ */
#pragma once
#ifndef INCLUDED_TINY_FORMATTER_H #ifndef INCLUDED_TINY_FORMATTER_H
#define INCLUDED_TINY_FORMATTER_H #define INCLUDED_TINY_FORMATTER_H
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <sstream> #include <sstream>
namespace Assimp { namespace Assimp {
@ -65,24 +70,15 @@ namespace Formatter {
* @endcode */ * @endcode */
template < typename T, template < typename T,
typename CharTraits = std::char_traits<T>, typename CharTraits = std::char_traits<T>,
typename Allocator = std::allocator<T> typename Allocator = std::allocator<T> >
> class basic_formatter {
class basic_formatter
{
public: public:
typedef class std::basic_string<T,CharTraits,Allocator> string;
typedef class std::basic_ostringstream<T,CharTraits,Allocator> stringstream;
typedef class std::basic_string< basic_formatter() {
T,CharTraits,Allocator // empty
> string; }
typedef class std::basic_ostringstream<
T,CharTraits,Allocator
> stringstream;
public:
basic_formatter() {}
/* Allow basic_formatter<T>'s to be used almost interchangeably /* Allow basic_formatter<T>'s to be used almost interchangeably
* with std::(w)string or const (w)char* arguments because the * with std::(w)string or const (w)char* arguments because the
@ -104,14 +100,10 @@ public:
} }
#endif #endif
public:
operator string () const { operator string () const {
return underlying.str(); return underlying.str();
} }
/* note - this is declared const because binding temporaries does only /* note - this is declared const because binding temporaries does only
* work for const references, so many function prototypes will * work for const references, so many function prototypes will
* include const basic_formatter<T>& s but might still want to * include const basic_formatter<T>& s but might still want to

67
include/assimp/Vertex.h
View File

@ -47,12 +47,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
that are not currently well-defined (and would cause compile errors that are not currently well-defined (and would cause compile errors
due to missing operators in the math library), are commented. due to missing operators in the math library), are commented.
*/ */
#pragma once
#ifndef AI_VERTEX_H_INC #ifndef AI_VERTEX_H_INC
#define AI_VERTEX_H_INC #define AI_VERTEX_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/vector3.h> #include <assimp/vector3.h>
#include <assimp/mesh.h> #include <assimp/mesh.h>
#include <assimp/ai_assert.h> #include <assimp/ai_assert.h>
#include <functional> #include <functional>
namespace Assimp { namespace Assimp {
@ -91,23 +97,14 @@ namespace Assimp {
* to *all* vertex components equally. This is useful for stuff like interpolation * to *all* vertex components equally. This is useful for stuff like interpolation
* or subdivision, but won't work if special handling is required for some vertex components. */ * or subdivision, but won't work if special handling is required for some vertex components. */
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
class Vertex class Vertex {
{
friend Vertex operator + (const Vertex&,const Vertex&); friend Vertex operator + (const Vertex&,const Vertex&);
friend Vertex operator - (const Vertex&,const Vertex&); friend Vertex operator - (const Vertex&,const Vertex&);
// friend Vertex operator + (const Vertex&,ai_real);
// friend Vertex operator - (const Vertex&,ai_real);
friend Vertex operator * (const Vertex&,ai_real); friend Vertex operator * (const Vertex&,ai_real);
friend Vertex operator / (const Vertex&,ai_real); friend Vertex operator / (const Vertex&,ai_real);
// friend Vertex operator + (ai_real, const Vertex&);
// friend Vertex operator - (ai_real, const Vertex&);
friend Vertex operator * (ai_real, const Vertex&); friend Vertex operator * (ai_real, const Vertex&);
// friend Vertex operator / (ai_real, const Vertex&);
public: public:
Vertex() {} Vertex() {}
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@ -158,8 +155,6 @@ public:
} }
} }
public:
Vertex& operator += (const Vertex& v) { Vertex& operator += (const Vertex& v) {
*this = *this+v; *this = *this+v;
return *this; return *this;
@ -170,18 +165,6 @@ public:
return *this; return *this;
} }
/*
Vertex& operator += (ai_real v) {
*this = *this+v;
return *this;
}
Vertex& operator -= (ai_real v) {
*this = *this-v;
return *this;
}
*/
Vertex& operator *= (ai_real v) { Vertex& operator *= (ai_real v) {
*this = *this*v; *this = *this*v;
return *this; return *this;
@ -192,12 +175,9 @@ public:
return *this; return *this;
} }
public:
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
/** Convert back to non-interleaved storage */ /** Convert back to non-interleaved storage */
void SortBack(aiMesh* out, unsigned int idx) const { void SortBack(aiMesh* out, unsigned int idx) const {
ai_assert(idx<out->mNumVertices); ai_assert(idx<out->mNumVertices);
out->mVertices[idx] = position; out->mVertices[idx] = position;
@ -291,8 +271,6 @@ public:
aiColor4D colors[AI_MAX_NUMBER_OF_COLOR_SETS]; aiColor4D colors[AI_MAX_NUMBER_OF_COLOR_SETS];
}; };
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
AI_FORCE_INLINE Vertex operator + (const Vertex& v0,const Vertex& v1) { AI_FORCE_INLINE Vertex operator + (const Vertex& v0,const Vertex& v1) {
return Vertex::BinaryOp<std::plus>(v0,v1); return Vertex::BinaryOp<std::plus>(v0,v1);
@ -302,19 +280,6 @@ AI_FORCE_INLINE Vertex operator - (const Vertex& v0,const Vertex& v1) {
return Vertex::BinaryOp<std::minus>(v0,v1); return Vertex::BinaryOp<std::minus>(v0,v1);
} }
// ------------------------------------------------------------------------------------------------
/*
AI_FORCE_INLINE Vertex operator + (const Vertex& v0,ai_real f) {
return Vertex::BinaryOp<Intern::plus>(v0,f);
}
AI_FORCE_INLINE Vertex operator - (const Vertex& v0,ai_real f) {
return Vertex::BinaryOp<Intern::minus>(v0,f);
}
*/
AI_FORCE_INLINE Vertex operator * (const Vertex& v0,ai_real f) { AI_FORCE_INLINE Vertex operator * (const Vertex& v0,ai_real f) {
return Vertex::BinaryOp<Intern::multiplies>(v0,f); return Vertex::BinaryOp<Intern::multiplies>(v0,f);
} }
@ -323,26 +288,10 @@ AI_FORCE_INLINE Vertex operator / (const Vertex& v0,ai_real f) {
return Vertex::BinaryOp<Intern::multiplies>(v0,1.f/f); return Vertex::BinaryOp<Intern::multiplies>(v0,1.f/f);
} }
// ------------------------------------------------------------------------------------------------
/*
AI_FORCE_INLINE Vertex operator + (ai_real f,const Vertex& v0) {
return Vertex::BinaryOp<Intern::plus>(f,v0);
}
AI_FORCE_INLINE Vertex operator - (ai_real f,const Vertex& v0) {
return Vertex::BinaryOp<Intern::minus>(f,v0);
}
*/
AI_FORCE_INLINE Vertex operator * (ai_real f,const Vertex& v0) { AI_FORCE_INLINE Vertex operator * (ai_real f,const Vertex& v0) {
return Vertex::BinaryOp<Intern::multiplies>(f,v0); return Vertex::BinaryOp<Intern::multiplies>(f,v0);
} }
/*
AI_FORCE_INLINE Vertex operator / (ai_real f,const Vertex& v0) {
return Vertex::BinaryOp<Intern::divides>(f,v0);
} }
*/
} #endif // AI_VERTEX_H_INC
#endif

5
include/assimp/XMLTools.h
View File

@ -40,9 +40,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
#pragma once
#ifndef INCLUDED_ASSIMP_XML_TOOLS_H #ifndef INCLUDED_ASSIMP_XML_TOOLS_H
#define INCLUDED_ASSIMP_XML_TOOLS_H #define INCLUDED_ASSIMP_XML_TOOLS_H
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <string> #include <string>
namespace Assimp { namespace Assimp {

57
include/assimp/ZipArchiveIOSystem.h
View File

@ -45,43 +45,50 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* @brief Implementation of IOSystem to read a ZIP file from another IOSystem * @brief Implementation of IOSystem to read a ZIP file from another IOSystem
*/ */
#pragma once
#ifndef AI_ZIPARCHIVEIOSYSTEM_H_INC #ifndef AI_ZIPARCHIVEIOSYSTEM_H_INC
#define AI_ZIPARCHIVEIOSYSTEM_H_INC #define AI_ZIPARCHIVEIOSYSTEM_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/IOStream.hpp> #include <assimp/IOStream.hpp>
#include <assimp/IOSystem.hpp> #include <assimp/IOSystem.hpp>
namespace Assimp { namespace Assimp {
class ZipArchiveIOSystem : public IOSystem {
public:
//! Open a Zip using the proffered IOSystem
ZipArchiveIOSystem(IOSystem* pIOHandler, const char *pFilename, const char* pMode = "r");
ZipArchiveIOSystem(IOSystem* pIOHandler, const std::string& rFilename, const char* pMode = "r");
virtual ~ZipArchiveIOSystem();
bool Exists(const char* pFilename) const override;
char getOsSeparator() const override;
IOStream* Open(const char* pFilename, const char* pMode = "rb") override;
void Close(IOStream* pFile) override;
// Specific to ZIP class ZipArchiveIOSystem : public IOSystem {
//! The file was opened and is a ZIP public:
bool isOpen() const; //! Open a Zip using the proffered IOSystem
ZipArchiveIOSystem(IOSystem* pIOHandler, const char *pFilename, const char* pMode = "r");
ZipArchiveIOSystem(IOSystem* pIOHandler, const std::string& rFilename, const char* pMode = "r");
virtual ~ZipArchiveIOSystem();
bool Exists(const char* pFilename) const override;
char getOsSeparator() const override;
IOStream* Open(const char* pFilename, const char* pMode = "rb") override;
void Close(IOStream* pFile) override;
//! Get the list of all files with their simplified paths // Specific to ZIP
//! Intended for use within Assimp library boundaries //! The file was opened and is a ZIP
void getFileList(std::vector<std::string>& rFileList) const; bool isOpen() const;
//! Get the list of all files with extension (must be lowercase) //! Get the list of all files with their simplified paths
//! Intended for use within Assimp library boundaries //! Intended for use within Assimp library boundaries
void getFileListExtension(std::vector<std::string>& rFileList, const std::string& extension) const; void getFileList(std::vector<std::string>& rFileList) const;
static bool isZipArchive(IOSystem* pIOHandler, const char *pFilename); //! Get the list of all files with extension (must be lowercase)
static bool isZipArchive(IOSystem* pIOHandler, const std::string& rFilename); //! Intended for use within Assimp library boundaries
void getFileListExtension(std::vector<std::string>& rFileList, const std::string& extension) const;
static bool isZipArchive(IOSystem* pIOHandler, const char *pFilename);
static bool isZipArchive(IOSystem* pIOHandler, const std::string& rFilename);
private:
class Implement;
Implement *pImpl = nullptr;
};
private:
class Implement;
Implement *pImpl = nullptr;
};
} // Namespace Assimp } // Namespace Assimp
#endif // AI_ZIPARCHIVEIOSYSTEM_H_INC #endif // AI_ZIPARCHIVEIOSYSTEM_H_INC

11
include/assimp/aabb.h
View File

@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2019, assimp team Copyright (c) 2006-2019, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -45,6 +43,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_AABB_H_INC #ifndef AI_AABB_H_INC
#define AI_AABB_H_INC #define AI_AABB_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/vector3.h> #include <assimp/vector3.h>
struct aiAABB { struct aiAABB {
@ -69,8 +71,9 @@ struct aiAABB {
// empty // empty
} }
#endif #endif // __cplusplus
}; };
#endif #endif // AI_AABB_H_INC

4
include/assimp/ai_assert.h
View File

@ -44,6 +44,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_ASSERT_H_INC #ifndef AI_ASSERT_H_INC
#define AI_ASSERT_H_INC #define AI_ASSERT_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#ifdef ASSIMP_BUILD_DEBUG #ifdef ASSIMP_BUILD_DEBUG
# include <assert.h> # include <assert.h>
# define ai_assert(expression) assert( expression ) # define ai_assert(expression) assert( expression )

4
include/assimp/anim.h
View File

@ -50,6 +50,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_ANIM_H_INC #ifndef AI_ANIM_H_INC
#define AI_ANIM_H_INC #define AI_ANIM_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/types.h> #include <assimp/types.h>
#include <assimp/quaternion.h> #include <assimp/quaternion.h>

4
include/assimp/camera.h
View File

@ -47,6 +47,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_CAMERA_H_INC #ifndef AI_CAMERA_H_INC
#define AI_CAMERA_H_INC #define AI_CAMERA_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include "types.h" #include "types.h"
#ifdef __cplusplus #ifdef __cplusplus

6
include/assimp/cexport.h
View File

@ -3,7 +3,7 @@
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2011, assimp team Copyright (c) 2006-2019, assimp team
All rights reserved. All rights reserved.
@ -46,6 +46,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_EXPORT_H_INC #ifndef AI_EXPORT_H_INC
#define AI_EXPORT_H_INC #define AI_EXPORT_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#ifndef ASSIMP_BUILD_NO_EXPORT #ifndef ASSIMP_BUILD_NO_EXPORT
// Public ASSIMP data structures // Public ASSIMP data structures

6
include/assimp/cfileio.h
View File

@ -48,10 +48,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_FILEIO_H_INC #ifndef AI_FILEIO_H_INC
#define AI_FILEIO_H_INC #define AI_FILEIO_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/types.h> #include <assimp/types.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
struct aiFileIO; struct aiFileIO;
struct aiFile; struct aiFile;

6
include/assimp/cimport.h
View File

@ -48,8 +48,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_ASSIMP_H_INC #ifndef AI_ASSIMP_H_INC
#define AI_ASSIMP_H_INC #define AI_ASSIMP_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/types.h> #include <assimp/types.h>
#include "importerdesc.h" #include <assimp/importerdesc.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {

13
include/assimp/color4.h
View File

@ -47,7 +47,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_COLOR4D_H_INC #ifndef AI_COLOR4D_H_INC
#define AI_COLOR4D_H_INC #define AI_COLOR4D_H_INC
#include "defs.h" #ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/defs.h>
#ifdef __cplusplus #ifdef __cplusplus
@ -56,8 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* alpha component. Color values range from 0 to 1. */ * alpha component. Color values range from 0 to 1. */
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
class aiColor4t class aiColor4t {
{
public: public:
aiColor4t() AI_NO_EXCEPT : r(), g(), b(), a() {} aiColor4t() AI_NO_EXCEPT : r(), g(), b(), a() {}
aiColor4t (TReal _r, TReal _g, TReal _b, TReal _a) aiColor4t (TReal _r, TReal _g, TReal _b, TReal _a)
@ -65,14 +68,12 @@ public:
explicit aiColor4t (TReal _r) : r(_r), g(_r), b(_r), a(_r) {} explicit aiColor4t (TReal _r) : r(_r), g(_r), b(_r), a(_r) {}
aiColor4t (const aiColor4t& o) = default; aiColor4t (const aiColor4t& o) = default;
public:
// combined operators // combined operators
const aiColor4t& operator += (const aiColor4t& o); const aiColor4t& operator += (const aiColor4t& o);
const aiColor4t& operator -= (const aiColor4t& o); const aiColor4t& operator -= (const aiColor4t& o);
const aiColor4t& operator *= (TReal f); const aiColor4t& operator *= (TReal f);
const aiColor4t& operator /= (TReal f); const aiColor4t& operator /= (TReal f);
public:
// comparison // comparison
bool operator == (const aiColor4t& other) const; bool operator == (const aiColor4t& other) const;
bool operator != (const aiColor4t& other) const; bool operator != (const aiColor4t& other) const;
@ -85,8 +86,6 @@ public:
/** check whether a color is (close to) black */ /** check whether a color is (close to) black */
inline bool IsBlack() const; inline bool IsBlack() const;
public:
// Red, green, blue and alpha color values // Red, green, blue and alpha color values
TReal r, g, b, a; TReal r, g, b, a;
}; // !struct aiColor4D }; // !struct aiColor4D

94
include/assimp/color4.inl
View File

@ -48,36 +48,61 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_COLOR4D_INL_INC #ifndef AI_COLOR4D_INL_INC
#define AI_COLOR4D_INL_INC #define AI_COLOR4D_INL_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#ifdef __cplusplus #ifdef __cplusplus
#include "color4.h" #include <assimp/color4.h>
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator += (const aiColor4t<TReal>& o) { AI_FORCE_INLINE
r += o.r; g += o.g; b += o.b; a += o.a; const aiColor4t<TReal>& aiColor4t<TReal>::operator += (const aiColor4t<TReal>& o) {
r += o.r;
g += o.g;
b += o.b;
a += o.a;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator -= (const aiColor4t<TReal>& o) { AI_FORCE_INLINE
r -= o.r; g -= o.g; b -= o.b; a -= o.a; const aiColor4t<TReal>& aiColor4t<TReal>::operator -= (const aiColor4t<TReal>& o) {
r -= o.r;
g -= o.g;
b -= o.b;
a -= o.a;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator *= (TReal f) { AI_FORCE_INLINE
r *= f; g *= f; b *= f; a *= f; const aiColor4t<TReal>& aiColor4t<TReal>::operator *= (TReal f) {
r *= f;
g *= f;
b *= f;
a *= f;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator /= (TReal f) { AI_FORCE_INLINE
r /= f; g /= f; b /= f; a /= f; const aiColor4t<TReal>& aiColor4t<TReal>::operator /= (TReal f) {
r /= f;
g /= f;
b /= f;
a /= f;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE TReal aiColor4t<TReal>::operator[](unsigned int i) const { AI_FORCE_INLINE
TReal aiColor4t<TReal>::operator[](unsigned int i) const {
switch ( i ) { switch ( i ) {
case 0: case 0:
return r; return r;
@ -94,7 +119,8 @@ AI_FORCE_INLINE TReal aiColor4t<TReal>::operator[](unsigned int i) const {
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE TReal& aiColor4t<TReal>::operator[](unsigned int i) { AI_FORCE_INLINE
TReal& aiColor4t<TReal>::operator[](unsigned int i) {
switch ( i ) { switch ( i ) {
case 0: case 0:
return r; return r;
@ -111,17 +137,20 @@ AI_FORCE_INLINE TReal& aiColor4t<TReal>::operator[](unsigned int i) {
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE bool aiColor4t<TReal>::operator== (const aiColor4t<TReal>& other) const { AI_FORCE_INLINE
bool aiColor4t<TReal>::operator== (const aiColor4t<TReal>& other) const {
return r == other.r && g == other.g && b == other.b && a == other.a; return r == other.r && g == other.g && b == other.b && a == other.a;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE bool aiColor4t<TReal>::operator!= (const aiColor4t<TReal>& other) const { AI_FORCE_INLINE
bool aiColor4t<TReal>::operator!= (const aiColor4t<TReal>& other) const {
return r != other.r || g != other.g || b != other.b || a != other.a; return r != other.r || g != other.g || b != other.b || a != other.a;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE bool aiColor4t<TReal>::operator< (const aiColor4t<TReal>& other) const { AI_FORCE_INLINE
bool aiColor4t<TReal>::operator< (const aiColor4t<TReal>& other) const {
return r < other.r || ( return r < other.r || (
r == other.r && ( r == other.r && (
g < other.g || ( g < other.g || (
@ -136,14 +165,17 @@ AI_FORCE_INLINE bool aiColor4t<TReal>::operator< (const aiColor4t<TReal>& other)
) )
); );
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator + (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2) { AI_FORCE_INLINE
aiColor4t<TReal> operator + (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2) {
return aiColor4t<TReal>( v1.r + v2.r, v1.g + v2.g, v1.b + v2.b, v1.a + v2.a); return aiColor4t<TReal>( v1.r + v2.r, v1.g + v2.g, v1.b + v2.b, v1.a + v2.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator - (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2) { AI_FORCE_INLINE
aiColor4t<TReal> operator - (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2) {
return aiColor4t<TReal>( v1.r - v2.r, v1.g - v2.g, v1.b - v2.b, v1.a - v2.a); return aiColor4t<TReal>( v1.r - v2.r, v1.g - v2.g, v1.b - v2.b, v1.a - v2.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -153,53 +185,63 @@ AI_FORCE_INLINE aiColor4t<TReal> operator * (const aiColor4t<TReal>& v1, const a
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator / (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2) { AI_FORCE_INLINE
aiColor4t<TReal> operator / (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2) {
return aiColor4t<TReal>( v1.r / v2.r, v1.g / v2.g, v1.b / v2.b, v1.a / v2.a); return aiColor4t<TReal>( v1.r / v2.r, v1.g / v2.g, v1.b / v2.b, v1.a / v2.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator * ( TReal f, const aiColor4t<TReal>& v) { AI_FORCE_INLINE
aiColor4t<TReal> operator * ( TReal f, const aiColor4t<TReal>& v) {
return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a); return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator * ( const aiColor4t<TReal>& v, TReal f) { AI_FORCE_INLINE
aiColor4t<TReal> operator * ( const aiColor4t<TReal>& v, TReal f) {
return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a); return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator / ( const aiColor4t<TReal>& v, TReal f) { AI_FORCE_INLINE
aiColor4t<TReal> operator / ( const aiColor4t<TReal>& v, TReal f) {
return v * (1/f); return v * (1/f);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator / ( TReal f,const aiColor4t<TReal>& v) { AI_FORCE_INLINE
aiColor4t<TReal> operator / ( TReal f,const aiColor4t<TReal>& v) {
return aiColor4t<TReal>(f,f,f,f)/v; return aiColor4t<TReal>(f,f,f,f)/v;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator + ( const aiColor4t<TReal>& v, TReal f) { AI_FORCE_INLINE
aiColor4t<TReal> operator + ( const aiColor4t<TReal>& v, TReal f) {
return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a); return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator - ( const aiColor4t<TReal>& v, TReal f) { AI_FORCE_INLINE
aiColor4t<TReal> operator - ( const aiColor4t<TReal>& v, TReal f) {
return aiColor4t<TReal>( v.r-f, v.g-f, v.b-f, v.a-f); return aiColor4t<TReal>( v.r-f, v.g-f, v.b-f, v.a-f);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator + ( TReal f, const aiColor4t<TReal>& v) { AI_FORCE_INLINE
aiColor4t<TReal> operator + ( TReal f, const aiColor4t<TReal>& v) {
return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a); return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator - ( TReal f, const aiColor4t<TReal>& v) { AI_FORCE_INLINE
aiColor4t<TReal> operator - ( TReal f, const aiColor4t<TReal>& v) {
return aiColor4t<TReal>( f-v.r, f-v.g, f-v.b, f-v.a); return aiColor4t<TReal>( f-v.r, f-v.g, f-v.b, f-v.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline bool aiColor4t<TReal> :: IsBlack() const { AI_FORCE_INLINE
bool aiColor4t<TReal>::IsBlack() const {
// The alpha component doesn't care here. black is black. // The alpha component doesn't care here. black is black.
static const TReal epsilon = 10e-3f; static const TReal epsilon = 10e-3f;
return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon; return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon;

22
include/assimp/defs.h
View File

@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2019, assimp team Copyright (c) 2006-2019, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -50,6 +48,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_DEFINES_H_INC #ifndef AI_DEFINES_H_INC
#define AI_DEFINES_H_INC #define AI_DEFINES_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/config.h> #include <assimp/config.h>
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -291,9 +293,10 @@ static const ai_real ai_epsilon = (ai_real) 0.00001;
#endif #endif
/* To avoid running out of memory /**
* This can be adjusted for specific use cases * To avoid running out of memory
* It's NOT a total limit, just a limit for individual allocations * This can be adjusted for specific use cases
* It's NOT a total limit, just a limit for individual allocations
*/ */
#define AI_MAX_ALLOC(type) ((256U * 1024 * 1024) / sizeof(type)) #define AI_MAX_ALLOC(type) ((256U * 1024 * 1024) / sizeof(type))
@ -307,4 +310,13 @@ static const ai_real ai_epsilon = (ai_real) 0.00001;
# endif # endif
#endif // _MSC_VER #endif // _MSC_VER
/**
* Helper macro to set a pointer to NULL in debug builds
*/
#if (defined ASSIMP_BUILD_DEBUG)
# define AI_DEBUG_INVALIDATE_PTR(x) x = NULL;
#else
# define AI_DEBUG_INVALIDATE_PTR(x)
#endif
#endif // !! AI_DEFINES_H_INC #endif // !! AI_DEFINES_H_INC

6
include/assimp/fast_atof.h
View File

@ -13,10 +13,14 @@
// to ensure long numbers are handled correctly // to ensure long numbers are handled correctly
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
#pragma once
#ifndef FAST_A_TO_F_H_INCLUDED #ifndef FAST_A_TO_F_H_INCLUDED
#define FAST_A_TO_F_H_INCLUDED #define FAST_A_TO_F_H_INCLUDED
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <cmath> #include <cmath>
#include <limits> #include <limits>
#include <stdint.h> #include <stdint.h>

10
include/assimp/importerdesc.h
View File

@ -48,11 +48,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_IMPORTER_DESC_H_INC #ifndef AI_IMPORTER_DESC_H_INC
#define AI_IMPORTER_DESC_H_INC #define AI_IMPORTER_DESC_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
/** Mixed set of flags for #aiImporterDesc, indicating some features /** Mixed set of flags for #aiImporterDesc, indicating some features
* common to many importers*/ * common to many importers*/
enum aiImporterFlags enum aiImporterFlags {
{
/** Indicates that there is a textual encoding of the /** Indicates that there is a textual encoding of the
* file format; and that it is supported.*/ * file format; and that it is supported.*/
aiImporterFlags_SupportTextFlavour = 0x1, aiImporterFlags_SupportTextFlavour = 0x1,
@ -87,8 +90,7 @@ enum aiImporterFlags
* as importers/exporters are added to Assimp, so it might be useful * as importers/exporters are added to Assimp, so it might be useful
* to have a common mechanism to query some rough importer * to have a common mechanism to query some rough importer
* characteristics. */ * characteristics. */
struct aiImporterDesc struct aiImporterDesc {
{
/** Full name of the importer (i.e. Blender3D importer)*/ /** Full name of the importer (i.e. Blender3D importer)*/
const char* mName; const char* mName;

6
include/assimp/light.h
View File

@ -49,7 +49,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_LIGHT_H_INC #ifndef AI_LIGHT_H_INC
#define AI_LIGHT_H_INC #define AI_LIGHT_H_INC
#include "types.h" #ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/types.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {

6
include/assimp/material.h
View File

@ -48,7 +48,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_MATERIAL_H_INC #ifndef AI_MATERIAL_H_INC
#define AI_MATERIAL_H_INC #define AI_MATERIAL_H_INC
#include "types.h" #ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/types.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {

265
include/assimp/material.inl
View File

@ -49,14 +49,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_MATERIAL_INL_INC #ifndef AI_MATERIAL_INL_INC
#define AI_MATERIAL_INL_INC #define AI_MATERIAL_INL_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiPropertyTypeInfo ai_real_to_property_type_info(float) AI_FORCE_INLINE
{ aiPropertyTypeInfo ai_real_to_property_type_info(float) {
return aiPTI_Float; return aiPTI_Float;
} }
inline aiPropertyTypeInfo ai_real_to_property_type_info(double) AI_FORCE_INLINE
{ aiPropertyTypeInfo ai_real_to_property_type_info(double) {
return aiPTI_Double; return aiPTI_Double;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -64,30 +68,30 @@ inline aiPropertyTypeInfo ai_real_to_property_type_info(double)
//! @cond never //! @cond never
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::GetTexture( aiTextureType type, AI_FORCE_INLINE
unsigned int index, aiReturn aiMaterial::GetTexture( aiTextureType type,
C_STRUCT aiString* path, unsigned int index,
aiTextureMapping* mapping /*= NULL*/, C_STRUCT aiString* path,
unsigned int* uvindex /*= NULL*/, aiTextureMapping* mapping /*= NULL*/,
ai_real* blend /*= NULL*/, unsigned int* uvindex /*= NULL*/,
aiTextureOp* op /*= NULL*/, ai_real* blend /*= NULL*/,
aiTextureMapMode* mapmode /*= NULL*/) const aiTextureOp* op /*= NULL*/,
{ aiTextureMapMode* mapmode /*= NULL*/) const {
return ::aiGetMaterialTexture(this,type,index,path,mapping,uvindex,blend,op,mapmode); return ::aiGetMaterialTexture(this,type,index,path,mapping,uvindex,blend,op,mapmode);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline unsigned int aiMaterial::GetTextureCount(aiTextureType type) const AI_FORCE_INLINE
{ unsigned int aiMaterial::GetTextureCount(aiTextureType type) const {
return ::aiGetMaterialTextureCount(this,type); return ::aiGetMaterialTextureCount(this,type);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template <typename Type> template <typename Type>
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, AI_FORCE_INLINE
unsigned int idx, Type* pOut, aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int* pMax) const unsigned int idx, Type* pOut,
{ unsigned int* pMax) const {
unsigned int iNum = pMax ? *pMax : 1; unsigned int iNum = pMax ? *pMax : 1;
const aiMaterialProperty* prop; const aiMaterialProperty* prop;
@ -114,9 +118,9 @@ inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template <typename Type> template <typename Type>
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, AI_FORCE_INLINE
unsigned int idx,Type& pOut) const aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
{ unsigned int idx,Type& pOut) const {
const aiMaterialProperty* prop; const aiMaterialProperty* prop;
const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx, const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx,
(const aiMaterialProperty**)&prop); (const aiMaterialProperty**)&prop);
@ -136,60 +140,56 @@ inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, AI_FORCE_INLINE
unsigned int idx,ai_real* pOut, aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int* pMax) const unsigned int idx,ai_real* pOut,
{ unsigned int* pMax) const {
return ::aiGetMaterialFloatArray(this,pKey,type,idx,pOut,pMax); return ::aiGetMaterialFloatArray(this,pKey,type,idx,pOut,pMax);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, AI_FORCE_INLINE
unsigned int idx,int* pOut, aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int* pMax) const unsigned int idx,int* pOut,
{ unsigned int* pMax) const {
return ::aiGetMaterialIntegerArray(this,pKey,type,idx,pOut,pMax); return ::aiGetMaterialIntegerArray(this,pKey,type,idx,pOut,pMax);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, AI_FORCE_INLINE
unsigned int idx,ai_real& pOut) const aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
{ unsigned int idx,ai_real& pOut) const {
return aiGetMaterialFloat(this,pKey,type,idx,&pOut); return aiGetMaterialFloat(this,pKey,type,idx,&pOut);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, AI_FORCE_INLINE
unsigned int idx,int& pOut) const aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
{ unsigned int idx,int& pOut) const {
return aiGetMaterialInteger(this,pKey,type,idx,&pOut); return aiGetMaterialInteger(this,pKey,type,idx,&pOut);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, AI_FORCE_INLINE
unsigned int idx,aiColor4D& pOut) const aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
{ unsigned int idx,aiColor4D& pOut) const {
return aiGetMaterialColor(this,pKey,type,idx,&pOut); return aiGetMaterialColor(this,pKey,type,idx,&pOut);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,aiColor3D& pOut) const unsigned int idx,aiColor3D& pOut) const {
{
aiColor4D c; aiColor4D c;
const aiReturn ret = aiGetMaterialColor(this,pKey,type,idx,&c); const aiReturn ret = aiGetMaterialColor(this,pKey,type,idx,&c);
pOut = aiColor3D(c.r,c.g,c.b); pOut = aiColor3D(c.r,c.g,c.b);
return ret; return ret;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,aiString& pOut) const unsigned int idx,aiString& pOut) const {
{
return aiGetMaterialString(this,pKey,type,idx,&pOut); return aiGetMaterialString(this,pKey,type,idx,&pOut);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,aiUVTransform& pOut) const unsigned int idx,aiUVTransform& pOut) const {
{
return aiGetMaterialUVTransform(this,pKey,type,idx,&pOut); return aiGetMaterialUVTransform(this,pKey,type,idx,&pOut);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<class TYPE> template<class TYPE>
aiReturn aiMaterial::AddProperty (const TYPE* pInput, aiReturn aiMaterial::AddProperty (const TYPE* pInput,
@ -204,84 +204,83 @@ aiReturn aiMaterial::AddProperty (const TYPE* pInput,
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const float* pInput, AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const float* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
unsigned int index) unsigned int index) {
{
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(float), pNumValues * sizeof(float),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const double* pInput, AI_FORCE_INLINE
const unsigned int pNumValues, aiReturn aiMaterial::AddProperty(const double* pInput,
const char* pKey, const unsigned int pNumValues,
unsigned int type, const char* pKey,
unsigned int index) unsigned int type,
{ unsigned int index) {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(double), pNumValues * sizeof(double),
pKey,type,index,aiPTI_Double); pKey,type,index,aiPTI_Double);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput, AI_FORCE_INLINE
const unsigned int pNumValues, aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput,
const char* pKey, const unsigned int pNumValues,
unsigned int type, const char* pKey,
unsigned int index) unsigned int type,
{ unsigned int index) {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiUVTransform), pNumValues * sizeof(aiUVTransform),
pKey,type,index,ai_real_to_property_type_info(pInput->mRotation)); pKey,type,index,ai_real_to_property_type_info(pInput->mRotation));
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const aiColor4D* pInput, AI_FORCE_INLINE
const unsigned int pNumValues, aiReturn aiMaterial::AddProperty(const aiColor4D* pInput,
const char* pKey, const unsigned int pNumValues,
unsigned int type, const char* pKey,
unsigned int index) unsigned int type,
{ unsigned int index) {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiColor4D), pNumValues * sizeof(aiColor4D),
pKey,type,index,ai_real_to_property_type_info(pInput->a)); pKey,type,index,ai_real_to_property_type_info(pInput->a));
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const aiColor3D* pInput, AI_FORCE_INLINE
const unsigned int pNumValues, aiReturn aiMaterial::AddProperty(const aiColor3D* pInput,
const char* pKey, const unsigned int pNumValues,
unsigned int type, const char* pKey,
unsigned int index) unsigned int type,
{ unsigned int index) {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiColor3D), pNumValues * sizeof(aiColor3D),
pKey,type,index,ai_real_to_property_type_info(pInput->b)); pKey,type,index,ai_real_to_property_type_info(pInput->b));
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const aiVector3D* pInput, AI_FORCE_INLINE
const unsigned int pNumValues, aiReturn aiMaterial::AddProperty(const aiVector3D* pInput,
const char* pKey, const unsigned int pNumValues,
unsigned int type, const char* pKey,
unsigned int index) unsigned int type,
{ unsigned int index) {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiVector3D), pNumValues * sizeof(aiVector3D),
pKey,type,index,ai_real_to_property_type_info(pInput->x)); pKey,type,index,ai_real_to_property_type_info(pInput->x));
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const int* pInput, AI_FORCE_INLINE
const unsigned int pNumValues, aiReturn aiMaterial::AddProperty(const int* pInput,
const char* pKey, const unsigned int pNumValues,
unsigned int type, const char* pKey,
unsigned int index) unsigned int type,
{ unsigned int index) {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(int), pNumValues * sizeof(int),
pKey,type,index,aiPTI_Integer); pKey,type,index,aiPTI_Integer);
@ -296,12 +295,12 @@ inline aiReturn aiMaterial::AddProperty(const int* pInput,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<float>(const float* pInput, AI_FORCE_INLINE
const unsigned int pNumValues, aiReturn aiMaterial::AddProperty<float>(const float* pInput,
const char* pKey, const unsigned int pNumValues,
unsigned int type, const char* pKey,
unsigned int index) unsigned int type,
{ unsigned int index) {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(float), pNumValues * sizeof(float),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
@ -309,12 +308,12 @@ inline aiReturn aiMaterial::AddProperty<float>(const float* pInput,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<double>(const double* pInput, AI_FORCE_INLINE
const unsigned int pNumValues, aiReturn aiMaterial::AddProperty<double>(const double* pInput,
const char* pKey, const unsigned int pNumValues,
unsigned int type, const char* pKey,
unsigned int index) unsigned int type,
{ unsigned int index) {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(double), pNumValues * sizeof(double),
pKey,type,index,aiPTI_Double); pKey,type,index,aiPTI_Double);
@ -322,12 +321,12 @@ inline aiReturn aiMaterial::AddProperty<double>(const double* pInput,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput, AI_FORCE_INLINE
const unsigned int pNumValues, aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
const char* pKey, const unsigned int pNumValues,
unsigned int type, const char* pKey,
unsigned int index) unsigned int type,
{ unsigned int index) {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiUVTransform), pNumValues * sizeof(aiUVTransform),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
@ -335,12 +334,12 @@ inline aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInp
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput, AI_FORCE_INLINE
const unsigned int pNumValues, aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
const char* pKey, const unsigned int pNumValues,
unsigned int type, const char* pKey,
unsigned int index) unsigned int type,
{ unsigned int index) {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiColor4D), pNumValues * sizeof(aiColor4D),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
@ -348,12 +347,12 @@ inline aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput, AI_FORCE_INLINE
const unsigned int pNumValues, aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
const char* pKey, const unsigned int pNumValues,
unsigned int type, const char* pKey,
unsigned int index) unsigned int type,
{ unsigned int index) {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiColor3D), pNumValues * sizeof(aiColor3D),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
@ -361,12 +360,12 @@ inline aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput, AI_FORCE_INLINE
const unsigned int pNumValues, aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
const char* pKey, const unsigned int pNumValues,
unsigned int type, const char* pKey,
unsigned int index) unsigned int type,
{ unsigned int index) {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiVector3D), pNumValues * sizeof(aiVector3D),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
@ -374,12 +373,12 @@ inline aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<int>(const int* pInput, AI_FORCE_INLINE
const unsigned int pNumValues, aiReturn aiMaterial::AddProperty<int>(const int* pInput,
const char* pKey, const unsigned int pNumValues,
unsigned int type, const char* pKey,
unsigned int index) unsigned int type,
{ unsigned int index) {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(int), pNumValues * sizeof(int),
pKey,type,index,aiPTI_Integer); pKey,type,index,aiPTI_Integer);

15
include/assimp/matrix3x3.h
View File

@ -48,7 +48,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_MATRIX3X3_H_INC #ifndef AI_MATRIX3X3_H_INC
#define AI_MATRIX3X3_H_INC #define AI_MATRIX3X3_H_INC
#include "defs.h" #ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/defs.h>
#ifdef __cplusplus #ifdef __cplusplus
@ -65,10 +69,8 @@ template <typename T> class aiVector2t;
* defined thereby. * defined thereby.
*/ */
template <typename TReal> template <typename TReal>
class aiMatrix3x3t class aiMatrix3x3t {
{
public: public:
aiMatrix3x3t() AI_NO_EXCEPT : aiMatrix3x3t() AI_NO_EXCEPT :
a1(static_cast<TReal>(1.0f)), a2(), a3(), a1(static_cast<TReal>(1.0f)), a2(), a3(),
b1(), b2(static_cast<TReal>(1.0f)), b3(), b1(), b2(static_cast<TReal>(1.0f)), b3(),
@ -82,8 +84,6 @@ public:
c1(_c1), c2(_c2), c3(_c3) c1(_c1), c2(_c2), c3(_c3)
{} {}
public:
// matrix multiplication. // matrix multiplication.
aiMatrix3x3t& operator *= (const aiMatrix3x3t& m); aiMatrix3x3t& operator *= (const aiMatrix3x3t& m);
aiMatrix3x3t operator * (const aiMatrix3x3t& m) const; aiMatrix3x3t operator * (const aiMatrix3x3t& m) const;
@ -101,8 +101,6 @@ public:
template <typename TOther> template <typename TOther>
operator aiMatrix3x3t<TOther> () const; operator aiMatrix3x3t<TOther> () const;
public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Construction from a 4x4 matrix. The remaining parts /** @brief Construction from a 4x4 matrix. The remaining parts
* of the matrix are ignored. * of the matrix are ignored.
@ -122,7 +120,6 @@ public:
aiMatrix3x3t& Inverse(); aiMatrix3x3t& Inverse();
TReal Determinant() const; TReal Determinant() const;
public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a rotation matrix for a rotation around z /** @brief Returns a rotation matrix for a rotation around z
* @param a Rotation angle, in radians * @param a Rotation angle, in radians

72
include/assimp/matrix3x3.inl
View File

@ -48,10 +48,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_MATRIX3X3_INL_INC #ifndef AI_MATRIX3X3_INL_INC
#define AI_MATRIX3X3_INL_INC #define AI_MATRIX3X3_INL_INC
#ifdef __cplusplus #ifdef __GNUC__
#include "matrix3x3.h" # pragma GCC system_header
#endif
#ifdef __cplusplus
#include <assimp/matrix3x3.h>
#include <assimp/matrix4x4.h>
#include "matrix4x4.h"
#include <algorithm> #include <algorithm>
#include <cmath> #include <cmath>
#include <limits> #include <limits>
@ -59,8 +63,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Construction from a 4x4 matrix. The remaining parts of the matrix are ignored. // Construction from a 4x4 matrix. The remaining parts of the matrix are ignored.
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>::aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix) AI_FORCE_INLINE
{ aiMatrix3x3t<TReal>::aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix) {
a1 = pMatrix.a1; a2 = pMatrix.a2; a3 = pMatrix.a3; a1 = pMatrix.a1; a2 = pMatrix.a2; a3 = pMatrix.a3;
b1 = pMatrix.b1; b2 = pMatrix.b2; b3 = pMatrix.b3; b1 = pMatrix.b1; b2 = pMatrix.b2; b3 = pMatrix.b3;
c1 = pMatrix.c1; c2 = pMatrix.c2; c3 = pMatrix.c3; c1 = pMatrix.c1; c2 = pMatrix.c2; c3 = pMatrix.c3;
@ -68,8 +72,8 @@ inline aiMatrix3x3t<TReal>::aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& m) AI_FORCE_INLINE
{ aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& m) {
*this = aiMatrix3x3t<TReal>(m.a1 * a1 + m.b1 * a2 + m.c1 * a3, *this = aiMatrix3x3t<TReal>(m.a1 * a1 + m.b1 * a2 + m.c1 * a3,
m.a2 * a1 + m.b2 * a2 + m.c2 * a3, m.a2 * a1 + m.b2 * a2 + m.c2 * a3,
m.a3 * a1 + m.b3 * a2 + m.c3 * a3, m.a3 * a1 + m.b3 * a2 + m.c3 * a3,
@ -85,8 +89,7 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::operator *= (const aiMatrix3x3t
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
template <typename TOther> template <typename TOther>
aiMatrix3x3t<TReal>::operator aiMatrix3x3t<TOther> () const aiMatrix3x3t<TReal>::operator aiMatrix3x3t<TOther> () const {
{
return aiMatrix3x3t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3), return aiMatrix3x3t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),
static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3), static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),
static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3)); static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3));
@ -94,8 +97,8 @@ aiMatrix3x3t<TReal>::operator aiMatrix3x3t<TOther> () const
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal> aiMatrix3x3t<TReal>::operator* (const aiMatrix3x3t<TReal>& m) const AI_FORCE_INLINE
{ aiMatrix3x3t<TReal> aiMatrix3x3t<TReal>::operator* (const aiMatrix3x3t<TReal>& m) const {
aiMatrix3x3t<TReal> temp( *this); aiMatrix3x3t<TReal> temp( *this);
temp *= m; temp *= m;
return temp; return temp;
@ -103,7 +106,8 @@ inline aiMatrix3x3t<TReal> aiMatrix3x3t<TReal>::operator* (const aiMatrix3x3t<TR
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) { AI_FORCE_INLINE
TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) {
switch ( p_iIndex ) { switch ( p_iIndex ) {
case 0: case 0:
return &a1; return &a1;
@ -119,7 +123,8 @@ inline TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) {
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) const { AI_FORCE_INLINE
const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) const {
switch ( p_iIndex ) { switch ( p_iIndex ) {
case 0: case 0:
return &a1; return &a1;
@ -135,8 +140,8 @@ inline const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) cons
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline bool aiMatrix3x3t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const AI_FORCE_INLINE
{ bool aiMatrix3x3t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const {
return a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && return a1 == m.a1 && a2 == m.a2 && a3 == m.a3 &&
b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && b1 == m.b1 && b2 == m.b2 && b3 == m.b3 &&
c1 == m.c1 && c2 == m.c2 && c3 == m.c3; c1 == m.c1 && c2 == m.c2 && c3 == m.c3;
@ -144,14 +149,15 @@ inline bool aiMatrix3x3t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline bool aiMatrix3x3t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const AI_FORCE_INLINE
{ bool aiMatrix3x3t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const {
return !(*this == m); return !(*this == m);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
inline bool aiMatrix3x3t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const { AI_FORCE_INLINE
bool aiMatrix3x3t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
return return
std::abs(a1 - m.a1) <= epsilon && std::abs(a1 - m.a1) <= epsilon &&
std::abs(a2 - m.a2) <= epsilon && std::abs(a2 - m.a2) <= epsilon &&
@ -166,8 +172,8 @@ inline bool aiMatrix3x3t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsil
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Transpose() AI_FORCE_INLINE
{ aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Transpose() {
// (TReal&) don't remove, GCC complains cause of packed fields // (TReal&) don't remove, GCC complains cause of packed fields
std::swap( (TReal&)a2, (TReal&)b1); std::swap( (TReal&)a2, (TReal&)b1);
std::swap( (TReal&)a3, (TReal&)c1); std::swap( (TReal&)a3, (TReal&)c1);
@ -177,15 +183,15 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Transpose()
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline TReal aiMatrix3x3t<TReal>::Determinant() const AI_FORCE_INLINE
{ TReal aiMatrix3x3t<TReal>::Determinant() const {
return a1*b2*c3 - a1*b3*c2 + a2*b3*c1 - a2*b1*c3 + a3*b1*c2 - a3*b2*c1; return a1*b2*c3 - a1*b3*c2 + a2*b3*c1 - a2*b1*c3 + a3*b1*c2 - a3*b2*c1;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Inverse() AI_FORCE_INLINE
{ aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Inverse() {
// Compute the reciprocal determinant // Compute the reciprocal determinant
TReal det = Determinant(); TReal det = Determinant();
if(det == static_cast<TReal>(0.0)) if(det == static_cast<TReal>(0.0))
@ -219,8 +225,8 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Inverse()
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::RotationZ(TReal a, aiMatrix3x3t<TReal>& out) AI_FORCE_INLINE
{ aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::RotationZ(TReal a, aiMatrix3x3t<TReal>& out) {
out.a1 = out.b2 = std::cos(a); out.a1 = out.b2 = std::cos(a);
out.b1 = std::sin(a); out.b1 = std::sin(a);
out.a2 = - out.b1; out.a2 = - out.b1;
@ -234,8 +240,8 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::RotationZ(TReal a, aiMatrix3x3t
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Returns a rotation matrix for a rotation around an arbitrary axis. // Returns a rotation matrix for a rotation around an arbitrary axis.
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix3x3t<TReal>& out) AI_FORCE_INLINE
{ aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix3x3t<TReal>& out) {
TReal c = std::cos( a), s = std::sin( a), t = 1 - c; TReal c = std::cos( a), s = std::sin( a), t = 1 - c;
TReal x = axis.x, y = axis.y, z = axis.z; TReal x = axis.x, y = axis.y, z = axis.z;
@ -249,8 +255,8 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Rotation( TReal a, const aiVect
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<TReal>& v, aiMatrix3x3t<TReal>& out) AI_FORCE_INLINE
{ aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<TReal>& v, aiMatrix3x3t<TReal>& out) {
out = aiMatrix3x3t<TReal>(); out = aiMatrix3x3t<TReal>();
out.a3 = v.x; out.a3 = v.x;
out.b3 = v.y; out.b3 = v.y;
@ -268,9 +274,8 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<T
*/ */
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::FromToMatrix(const aiVector3t<TReal>& from, AI_FORCE_INLINE aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
const aiVector3t<TReal>& to, aiMatrix3x3t<TReal>& mtx) const aiVector3t<TReal>& to, aiMatrix3x3t<TReal>& mtx) {
{
const TReal e = from * to; const TReal e = from * to;
const TReal f = (e < 0)? -e:e; const TReal f = (e < 0)? -e:e;
@ -352,6 +357,5 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::FromToMatrix(const aiVector3t<T
return mtx; return mtx;
} }
#endif // __cplusplus #endif // __cplusplus
#endif // AI_MATRIX3X3_INL_INC #endif // AI_MATRIX3X3_INL_INC

18
include/assimp/matrix4x4.h
View File

@ -47,8 +47,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_MATRIX4X4_H_INC #ifndef AI_MATRIX4X4_H_INC
#define AI_MATRIX4X4_H_INC #define AI_MATRIX4X4_H_INC
#include "vector3.h" #ifdef __GNUC__
#include "defs.h" # pragma GCC system_header
#endif
#include <assimp/vector3.h>
#include <assimp/defs.h>
#ifdef __cplusplus #ifdef __cplusplus
@ -66,8 +70,7 @@ template<typename TReal> class aiQuaterniont;
* defined thereby. * defined thereby.
*/ */
template<typename TReal> template<typename TReal>
class aiMatrix4x4t class aiMatrix4x4t {
{
public: public:
/** set to identity */ /** set to identity */
@ -91,8 +94,6 @@ public:
aiMatrix4x4t(const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation, aiMatrix4x4t(const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation,
const aiVector3t<TReal>& position); const aiVector3t<TReal>& position);
public:
// array access operators // array access operators
/** @fn TReal* operator[] (unsigned int p_iIndex) /** @fn TReal* operator[] (unsigned int p_iIndex)
* @param [in] p_iIndex - index of the row. * @param [in] p_iIndex - index of the row.
@ -120,8 +121,6 @@ public:
template <typename TOther> template <typename TOther>
operator aiMatrix4x4t<TOther> () const; operator aiMatrix4x4t<TOther> () const;
public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Transpose the matrix */ /** @brief Transpose the matrix */
aiMatrix4x4t& Transpose(); aiMatrix4x4t& Transpose();
@ -182,7 +181,6 @@ public:
void DecomposeNoScaling (aiQuaterniont<TReal>& rotation, void DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
aiVector3t<TReal>& position) const; aiVector3t<TReal>& position) const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Creates a trafo matrix from a set of euler angles /** @brief Creates a trafo matrix from a set of euler angles
* @param x Rotation angle for the x-axis, in radians * @param x Rotation angle for the x-axis, in radians
@ -192,7 +190,6 @@ public:
aiMatrix4x4t& FromEulerAnglesXYZ(TReal x, TReal y, TReal z); aiMatrix4x4t& FromEulerAnglesXYZ(TReal x, TReal y, TReal z);
aiMatrix4x4t& FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb); aiMatrix4x4t& FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb);
public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a rotation matrix for a rotation around the x axis /** @brief Returns a rotation matrix for a rotation around the x axis
* @param a Rotation angle, in radians * @param a Rotation angle, in radians
@ -256,7 +253,6 @@ public:
static aiMatrix4x4t& FromToMatrix(const aiVector3t<TReal>& from, static aiMatrix4x4t& FromToMatrix(const aiVector3t<TReal>& from,
const aiVector3t<TReal>& to, aiMatrix4x4t& out); const aiVector3t<TReal>& to, aiMatrix4x4t& out);
public:
TReal a1, a2, a3, a4; TReal a1, a2, a3, a4;
TReal b1, b2, b3, b4; TReal b1, b2, b3, b4;
TReal c1, c2, c3, c4; TReal c1, c2, c3, c4;

168
include/assimp/matrix4x4.inl
View File

@ -60,12 +60,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
aiMatrix4x4t<TReal>::aiMatrix4x4t() AI_NO_EXCEPT : aiMatrix4x4t<TReal>::aiMatrix4x4t() AI_NO_EXCEPT :
a1(1.0f), a2(), a3(), a4(), a1(1.0f), a2(), a3(), a4(),
b1(), b2(1.0f), b3(), b4(), b1(), b2(1.0f), b3(), b4(),
c1(), c2(), c3(1.0f), c4(), c1(), c2(), c3(1.0f), c4(),
d1(), d2(), d3(), d4(1.0f) d1(), d2(), d3(), d4(1.0f) {
{ // empty
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
@ -74,19 +73,17 @@ aiMatrix4x4t<TReal>::aiMatrix4x4t (TReal _a1, TReal _a2, TReal _a3, TReal _a4,
TReal _b1, TReal _b2, TReal _b3, TReal _b4, TReal _b1, TReal _b2, TReal _b3, TReal _b4,
TReal _c1, TReal _c2, TReal _c3, TReal _c4, TReal _c1, TReal _c2, TReal _c3, TReal _c4,
TReal _d1, TReal _d2, TReal _d3, TReal _d4) : TReal _d1, TReal _d2, TReal _d3, TReal _d4) :
a1(_a1), a2(_a2), a3(_a3), a4(_a4), a1(_a1), a2(_a2), a3(_a3), a4(_a4),
b1(_b1), b2(_b2), b3(_b3), b4(_b4), b1(_b1), b2(_b2), b3(_b3), b4(_b4),
c1(_c1), c2(_c2), c3(_c3), c4(_c4), c1(_c1), c2(_c2), c3(_c3), c4(_c4),
d1(_d1), d2(_d2), d3(_d3), d4(_d4) d1(_d1), d2(_d2), d3(_d3), d4(_d4) {
{ // empty
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
template <typename TOther> template <typename TOther>
aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const {
{
return aiMatrix4x4t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),static_cast<TOther>(a4), return aiMatrix4x4t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),static_cast<TOther>(a4),
static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),static_cast<TOther>(b4), static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),static_cast<TOther>(b4),
static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3),static_cast<TOther>(c4), static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3),static_cast<TOther>(c4),
@ -96,8 +93,8 @@ aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiMatrix3x3t<TReal>& m) AI_FORCE_INLINE
{ aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiMatrix3x3t<TReal>& m) {
a1 = m.a1; a2 = m.a2; a3 = m.a3; a4 = static_cast<TReal>(0.0); a1 = m.a1; a2 = m.a2; a3 = m.a3; a4 = static_cast<TReal>(0.0);
b1 = m.b1; b2 = m.b2; b3 = m.b3; b4 = static_cast<TReal>(0.0); b1 = m.b1; b2 = m.b2; b3 = m.b3; b4 = static_cast<TReal>(0.0);
c1 = m.c1; c2 = m.c2; c3 = m.c3; c4 = static_cast<TReal>(0.0); c1 = m.c1; c2 = m.c2; c3 = m.c3; c4 = static_cast<TReal>(0.0);
@ -106,8 +103,8 @@ inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiMatrix3x3t<TReal>& m)
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation, const aiVector3t<TReal>& position) AI_FORCE_INLINE
{ aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation, const aiVector3t<TReal>& position) {
// build a 3x3 rotation matrix // build a 3x3 rotation matrix
aiMatrix3x3t<TReal> m = rotation.GetMatrix(); aiMatrix3x3t<TReal> m = rotation.GetMatrix();
@ -134,8 +131,8 @@ inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiVector3t<TReal>& scaling, cons
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::operator *= (const aiMatrix4x4t<TReal>& m) AI_FORCE_INLINE
{ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::operator *= (const aiMatrix4x4t<TReal>& m) {
*this = aiMatrix4x4t<TReal>( *this = aiMatrix4x4t<TReal>(
m.a1 * a1 + m.b1 * a2 + m.c1 * a3 + m.d1 * a4, m.a1 * a1 + m.b1 * a2 + m.c1 * a3 + m.d1 * a4,
m.a2 * a1 + m.b2 * a2 + m.c2 * a3 + m.d2 * a4, m.a2 * a1 + m.b2 * a2 + m.c2 * a3 + m.d2 * a4,
@ -158,8 +155,7 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::operator *= (const aiMatrix4x4t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const TReal& aFloat) const AI_FORCE_INLINE aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const TReal& aFloat) const {
{
aiMatrix4x4t<TReal> temp( aiMatrix4x4t<TReal> temp(
a1 * aFloat, a1 * aFloat,
a2 * aFloat, a2 * aFloat,
@ -182,8 +178,8 @@ inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const TReal& aFloat)
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator+ (const aiMatrix4x4t<TReal>& m) const AI_FORCE_INLINE
{ aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator+ (const aiMatrix4x4t<TReal>& m) const {
aiMatrix4x4t<TReal> temp( aiMatrix4x4t<TReal> temp(
m.a1 + a1, m.a1 + a1,
m.a2 + a2, m.a2 + a2,
@ -206,18 +202,16 @@ inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator+ (const aiMatrix4x4t<TR
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const aiMatrix4x4t<TReal>& m) const AI_FORCE_INLINE
{ aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const aiMatrix4x4t<TReal>& m) const {
aiMatrix4x4t<TReal> temp( *this); aiMatrix4x4t<TReal> temp( *this);
temp *= m; temp *= m;
return temp; return temp;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose() AI_FORCE_INLINE aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose() {
{
// (TReal&) don't remove, GCC complains cause of packed fields // (TReal&) don't remove, GCC complains cause of packed fields
std::swap( (TReal&)b1, (TReal&)a2); std::swap( (TReal&)b1, (TReal&)a2);
std::swap( (TReal&)c1, (TReal&)a3); std::swap( (TReal&)c1, (TReal&)a3);
@ -228,11 +222,10 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose()
return *this; return *this;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline TReal aiMatrix4x4t<TReal>::Determinant() const AI_FORCE_INLINE
{ TReal aiMatrix4x4t<TReal>::Determinant() const {
return a1*b2*c3*d4 - a1*b2*c4*d3 + a1*b3*c4*d2 - a1*b3*c2*d4 return a1*b2*c3*d4 - a1*b2*c4*d3 + a1*b3*c4*d2 - a1*b3*c2*d4
+ a1*b4*c2*d3 - a1*b4*c3*d2 - a2*b3*c4*d1 + a2*b3*c1*d4 + a1*b4*c2*d3 - a1*b4*c3*d2 - a2*b3*c4*d1 + a2*b3*c1*d4
- a2*b4*c1*d3 + a2*b4*c3*d1 - a2*b1*c3*d4 + a2*b1*c4*d3 - a2*b4*c1*d3 + a2*b4*c3*d1 - a2*b1*c3*d4 + a2*b1*c4*d3
@ -243,8 +236,8 @@ inline TReal aiMatrix4x4t<TReal>::Determinant() const
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Inverse() AI_FORCE_INLINE
{ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Inverse() {
// Compute the reciprocal determinant // Compute the reciprocal determinant
const TReal det = Determinant(); const TReal det = Determinant();
if(det == static_cast<TReal>(0.0)) if(det == static_cast<TReal>(0.0))
@ -288,9 +281,10 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Inverse()
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) { AI_FORCE_INLINE
TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) {
if (p_iIndex > 3) { if (p_iIndex > 3) {
return NULL; return nullptr;
} }
switch ( p_iIndex ) { switch ( p_iIndex ) {
case 0: case 0:
@ -309,9 +303,10 @@ inline TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) {
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline const TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) const { AI_FORCE_INLINE
const TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) const {
if (p_iIndex > 3) { if (p_iIndex > 3) {
return NULL; return nullptr;
} }
switch ( p_iIndex ) { switch ( p_iIndex ) {
@ -331,8 +326,8 @@ inline const TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) const
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline bool aiMatrix4x4t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const AI_FORCE_INLINE
{ bool aiMatrix4x4t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const {
return (a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && a4 == m.a4 && return (a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && a4 == m.a4 &&
b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && b4 == m.b4 && b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && b4 == m.b4 &&
c1 == m.c1 && c2 == m.c2 && c3 == m.c3 && c4 == m.c4 && c1 == m.c1 && c2 == m.c2 && c3 == m.c3 && c4 == m.c4 &&
@ -341,14 +336,15 @@ inline bool aiMatrix4x4t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline bool aiMatrix4x4t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const AI_FORCE_INLINE
{ bool aiMatrix4x4t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const {
return !(*this == m); return !(*this == m);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
inline bool aiMatrix4x4t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const { AI_FORCE_INLINE
bool aiMatrix4x4t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
return return
std::abs(a1 - m.a1) <= epsilon && std::abs(a1 - m.a1) <= epsilon &&
std::abs(a2 - m.a2) <= epsilon && std::abs(a2 - m.a2) <= epsilon &&
@ -400,13 +396,10 @@ inline bool aiMatrix4x4t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsil
\ \
do {} while(false) do {} while(false)
template <typename TReal> template <typename TReal>
inline void aiMatrix4x4t<TReal>::Decompose (aiVector3t<TReal>& pScaling, aiQuaterniont<TReal>& pRotation, AI_FORCE_INLINE
aiVector3t<TReal>& pPosition) const void aiMatrix4x4t<TReal>::Decompose (aiVector3t<TReal>& pScaling, aiQuaterniont<TReal>& pRotation,
{ aiVector3t<TReal>& pPosition) const {
ASSIMP_MATRIX4_4_DECOMPOSE_PART; ASSIMP_MATRIX4_4_DECOMPOSE_PART;
// build a 3x3 rotation matrix // build a 3x3 rotation matrix
@ -419,7 +412,7 @@ inline void aiMatrix4x4t<TReal>::Decompose (aiVector3t<TReal>& pScaling, aiQuate
} }
template <typename TReal> template <typename TReal>
inline AI_FORCE_INLINE
void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotation, aiVector3t<TReal>& pPosition) const { void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotation, aiVector3t<TReal>& pPosition) const {
ASSIMP_MATRIX4_4_DECOMPOSE_PART; ASSIMP_MATRIX4_4_DECOMPOSE_PART;
@ -474,10 +467,10 @@ void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TRea
#undef ASSIMP_MATRIX4_4_DECOMPOSE_PART #undef ASSIMP_MATRIX4_4_DECOMPOSE_PART
template <typename TReal> template <typename TReal>
inline void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotationAxis, TReal& pRotationAngle, AI_FORCE_INLINE
aiVector3t<TReal>& pPosition) const void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotationAxis, TReal& pRotationAngle,
{ aiVector3t<TReal>& pPosition) const {
aiQuaterniont<TReal> pRotation; aiQuaterniont<TReal> pRotation;
Decompose(pScaling, pRotation, pPosition); Decompose(pScaling, pRotation, pPosition);
pRotation.Normalize(); pRotation.Normalize();
@ -499,9 +492,9 @@ aiQuaterniont<TReal> pRotation;
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline void aiMatrix4x4t<TReal>::DecomposeNoScaling (aiQuaterniont<TReal>& rotation, AI_FORCE_INLINE
aiVector3t<TReal>& position) const void aiMatrix4x4t<TReal>::DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
{ aiVector3t<TReal>& position) const {
const aiMatrix4x4t<TReal>& _this = *this; const aiMatrix4x4t<TReal>& _this = *this;
// extract translation // extract translation
@ -515,15 +508,15 @@ inline void aiMatrix4x4t<TReal>::DecomposeNoScaling (aiQuaterniont<TReal>& rotat
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb) AI_FORCE_INLINE
{ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb) {
return FromEulerAnglesXYZ(blubb.x,blubb.y,blubb.z); return FromEulerAnglesXYZ(blubb.x,blubb.y,blubb.z);
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(TReal x, TReal y, TReal z) AI_FORCE_INLINE
{ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(TReal x, TReal y, TReal z) {
aiMatrix4x4t<TReal>& _this = *this; aiMatrix4x4t<TReal>& _this = *this;
TReal cx = std::cos(x); TReal cx = std::cos(x);
@ -551,8 +544,8 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(TReal x, TRe
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline bool aiMatrix4x4t<TReal>::IsIdentity() const AI_FORCE_INLINE
{ bool aiMatrix4x4t<TReal>::IsIdentity() const {
// Use a small epsilon to solve floating-point inaccuracies // Use a small epsilon to solve floating-point inaccuracies
const static TReal epsilon = 10e-3f; const static TReal epsilon = 10e-3f;
@ -576,8 +569,8 @@ inline bool aiMatrix4x4t<TReal>::IsIdentity() const
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationX(TReal a, aiMatrix4x4t<TReal>& out) AI_FORCE_INLINE
{ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationX(TReal a, aiMatrix4x4t<TReal>& out) {
/* /*
| 1 0 0 0 | | 1 0 0 0 |
M = | 0 cos(A) -sin(A) 0 | M = | 0 cos(A) -sin(A) 0 |
@ -591,8 +584,8 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationX(TReal a, aiMatrix4x4t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationY(TReal a, aiMatrix4x4t<TReal>& out) AI_FORCE_INLINE
{ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationY(TReal a, aiMatrix4x4t<TReal>& out) {
/* /*
| cos(A) 0 sin(A) 0 | | cos(A) 0 sin(A) 0 |
M = | 0 1 0 0 | M = | 0 1 0 0 |
@ -607,8 +600,8 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationY(TReal a, aiMatrix4x4t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationZ(TReal a, aiMatrix4x4t<TReal>& out) AI_FORCE_INLINE
{ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationZ(TReal a, aiMatrix4x4t<TReal>& out) {
/* /*
| cos(A) -sin(A) 0 0 | | cos(A) -sin(A) 0 0 |
M = | sin(A) cos(A) 0 0 | M = | sin(A) cos(A) 0 0 |
@ -623,26 +616,25 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationZ(TReal a, aiMatrix4x4t
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
// Returns a rotation matrix for a rotation around an arbitrary axis. // Returns a rotation matrix for a rotation around an arbitrary axis.
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix4x4t<TReal>& out) AI_FORCE_INLINE
{ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix4x4t<TReal>& out) {
TReal c = std::cos( a), s = std::sin( a), t = 1 - c; TReal c = std::cos( a), s = std::sin( a), t = 1 - c;
TReal x = axis.x, y = axis.y, z = axis.z; TReal x = axis.x, y = axis.y, z = axis.z;
// Many thanks to MathWorld and Wikipedia // Many thanks to MathWorld and Wikipedia
out.a1 = t*x*x + c; out.a2 = t*x*y - s*z; out.a3 = t*x*z + s*y; out.a1 = t*x*x + c; out.a2 = t*x*y - s*z; out.a3 = t*x*z + s*y;
out.b1 = t*x*y + s*z; out.b2 = t*y*y + c; out.b3 = t*y*z - s*x; out.b1 = t*x*y + s*z; out.b2 = t*y*y + c; out.b3 = t*y*z - s*x;
out.c1 = t*x*z - s*y; out.c2 = t*y*z + s*x; out.c3 = t*z*z + c; out.c1 = t*x*z - s*y; out.c2 = t*y*z + s*x; out.c3 = t*z*z + c;
out.a4 = out.b4 = out.c4 = static_cast<TReal>(0.0); out.a4 = out.b4 = out.c4 = static_cast<TReal>(0.0);
out.d1 = out.d2 = out.d3 = static_cast<TReal>(0.0); out.d1 = out.d2 = out.d3 = static_cast<TReal>(0.0);
out.d4 = static_cast<TReal>(1.0); out.d4 = static_cast<TReal>(1.0);
return out; return out;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Translation( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out) AI_FORCE_INLINE aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Translation( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out) {
{
out = aiMatrix4x4t<TReal>(); out = aiMatrix4x4t<TReal>();
out.a4 = v.x; out.a4 = v.x;
out.b4 = v.y; out.b4 = v.y;
@ -652,8 +644,8 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Translation( const aiVector3t<T
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out) AI_FORCE_INLINE
{ aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out) {
out = aiMatrix4x4t<TReal>(); out = aiMatrix4x4t<TReal>();
out.a1 = v.x; out.a1 = v.x;
out.b2 = v.y; out.b2 = v.y;
@ -672,9 +664,9 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal
*/ */
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromToMatrix(const aiVector3t<TReal>& from, AI_FORCE_INLINE
const aiVector3t<TReal>& to, aiMatrix4x4t<TReal>& mtx) aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
{ const aiVector3t<TReal>& to, aiMatrix4x4t<TReal>& mtx) {
aiMatrix3x3t<TReal> m3; aiMatrix3x3t<TReal> m3;
aiMatrix3x3t<TReal>::FromToMatrix(from,to,m3); aiMatrix3x3t<TReal>::FromToMatrix(from,to,m3);
mtx = aiMatrix4x4t<TReal>(m3); mtx = aiMatrix4x4t<TReal>(m3);

4
include/assimp/mesh.h
View File

@ -48,6 +48,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_MESH_H_INC #ifndef AI_MESH_H_INC
#define AI_MESH_H_INC #define AI_MESH_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/types.h> #include <assimp/types.h>
#include <assimp/aabb.h> #include <assimp/aabb.h>

4
include/assimp/metadata.h
View File

@ -48,6 +48,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_METADATA_H_INC #ifndef AI_METADATA_H_INC
#define AI_METADATA_H_INC #define AI_METADATA_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#if defined(_MSC_VER) && (_MSC_VER <= 1500) #if defined(_MSC_VER) && (_MSC_VER <= 1500)
# include "Compiler/pstdint.h" # include "Compiler/pstdint.h"
#else #else

7
include/assimp/pbrmaterial.h
View File

@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2019, assimp team Copyright (c) 2006-2019, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -44,9 +42,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file pbrmaterial.h /** @file pbrmaterial.h
* @brief Defines the material system of the library * @brief Defines the material system of the library
*/ */
#pragma once
#ifndef AI_PBRMATERIAL_H_INC #ifndef AI_PBRMATERIAL_H_INC
#define AI_PBRMATERIAL_H_INC #define AI_PBRMATERIAL_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_FACTOR "$mat.gltf.pbrMetallicRoughness.baseColorFactor", 0, 0 #define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_BASE_COLOR_FACTOR "$mat.gltf.pbrMetallicRoughness.baseColorFactor", 0, 0
#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLIC_FACTOR "$mat.gltf.pbrMetallicRoughness.metallicFactor", 0, 0 #define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLIC_FACTOR "$mat.gltf.pbrMetallicRoughness.metallicFactor", 0, 0
#define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_ROUGHNESS_FACTOR "$mat.gltf.pbrMetallicRoughness.roughnessFactor", 0, 0 #define AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_ROUGHNESS_FACTOR "$mat.gltf.pbrMetallicRoughness.roughnessFactor", 0, 0

6
include/assimp/postprocess.h
View File

@ -47,7 +47,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_POSTPROCESS_H_INC #ifndef AI_POSTPROCESS_H_INC
#define AI_POSTPROCESS_H_INC #define AI_POSTPROCESS_H_INC
#include "types.h" #include <assimp/types.h>
#ifdef __GNUC__
# pragma GCC system_header
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {

31
include/assimp/qnan.h
View File

@ -50,19 +50,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* but last time I checked compiler coverage was so bad that I decided * but last time I checked compiler coverage was so bad that I decided
* to reinvent the wheel. * to reinvent the wheel.
*/ */
#pragma once
#ifndef AI_QNAN_H_INCLUDED #ifndef AI_QNAN_H_INCLUDED
#define AI_QNAN_H_INCLUDED #define AI_QNAN_H_INCLUDED
#ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/defs.h> #include <assimp/defs.h>
#include <limits> #include <limits>
#include <stdint.h> #include <stdint.h>
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Data structure to represent the bit pattern of a 32 Bit /** Data structure to represent the bit pattern of a 32 Bit
* IEEE 754 floating-point number. */ * IEEE 754 floating-point number. */
union _IEEESingle union _IEEESingle {
{
float Float; float Float;
struct struct
{ {
@ -75,8 +79,7 @@ union _IEEESingle
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Data structure to represent the bit pattern of a 64 Bit /** Data structure to represent the bit pattern of a 64 Bit
* IEEE 754 floating-point number. */ * IEEE 754 floating-point number. */
union _IEEEDouble union _IEEEDouble {
{
double Double; double Double;
struct struct
{ {
@ -89,8 +92,7 @@ union _IEEEDouble
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Check whether a given float is qNaN. /** Check whether a given float is qNaN.
* @param in Input value */ * @param in Input value */
AI_FORCE_INLINE bool is_qnan(float in) AI_FORCE_INLINE bool is_qnan(float in) {
{
// the straightforward solution does not work: // the straightforward solution does not work:
// return (in != in); // return (in != in);
// compiler generates code like this // compiler generates code like this
@ -107,8 +109,7 @@ AI_FORCE_INLINE bool is_qnan(float in)
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Check whether a given double is qNaN. /** Check whether a given double is qNaN.
* @param in Input value */ * @param in Input value */
AI_FORCE_INLINE bool is_qnan(double in) AI_FORCE_INLINE bool is_qnan(double in) {
{
// the straightforward solution does not work: // the straightforward solution does not work:
// return (in != in); // return (in != in);
// compiler generates code like this // compiler generates code like this
@ -127,8 +128,7 @@ AI_FORCE_INLINE bool is_qnan(double in)
* *
* Denorms return false, they're treated like normal values. * Denorms return false, they're treated like normal values.
* @param in Input value */ * @param in Input value */
AI_FORCE_INLINE bool is_special_float(float in) AI_FORCE_INLINE bool is_special_float(float in) {
{
_IEEESingle temp; _IEEESingle temp;
memcpy(&temp, &in, sizeof(float)); memcpy(&temp, &in, sizeof(float));
return (temp.IEEE.Exp == (1u << 8)-1); return (temp.IEEE.Exp == (1u << 8)-1);
@ -139,8 +139,7 @@ AI_FORCE_INLINE bool is_special_float(float in)
* *
* Denorms return false, they're treated like normal values. * Denorms return false, they're treated like normal values.
* @param in Input value */ * @param in Input value */
AI_FORCE_INLINE bool is_special_float(double in) AI_FORCE_INLINE bool is_special_float(double in) {
{
_IEEESingle temp; _IEEESingle temp;
memcpy(&temp, &in, sizeof(float)); memcpy(&temp, &in, sizeof(float));
return (temp.IEEE.Exp == (1u << 11)-1); return (temp.IEEE.Exp == (1u << 11)-1);
@ -150,15 +149,13 @@ AI_FORCE_INLINE bool is_special_float(double in)
/** Check whether a float is NOT qNaN. /** Check whether a float is NOT qNaN.
* @param in Input value */ * @param in Input value */
template<class TReal> template<class TReal>
AI_FORCE_INLINE bool is_not_qnan(TReal in) AI_FORCE_INLINE bool is_not_qnan(TReal in) {
{
return !is_qnan(in); return !is_qnan(in);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Get a fresh qnan. */ /** @brief Get a fresh qnan. */
AI_FORCE_INLINE ai_real get_qnan() AI_FORCE_INLINE ai_real get_qnan() {
{
return std::numeric_limits<ai_real>::quiet_NaN(); return std::numeric_limits<ai_real>::quiet_NaN();
} }

6
include/assimp/quaternion.h
View File

@ -49,7 +49,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifdef __cplusplus #ifdef __cplusplus
#include "defs.h" #ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/defs.h>
template <typename TReal> class aiVector3t; template <typename TReal> class aiVector3t;
template <typename TReal> class aiMatrix3x3t; template <typename TReal> class aiMatrix3x3t;

6
include/assimp/quaternion.inl
View File

@ -48,8 +48,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_QUATERNION_INL_INC #ifndef AI_QUATERNION_INL_INC
#define AI_QUATERNION_INL_INC #define AI_QUATERNION_INL_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#ifdef __cplusplus #ifdef __cplusplus
#include "quaternion.h" #include <assimp/quaternion.h>
#include <cmath> #include <cmath>

20
include/assimp/scene.h
View File

@ -48,14 +48,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_SCENE_H_INC #ifndef AI_SCENE_H_INC
#define AI_SCENE_H_INC #define AI_SCENE_H_INC
#include "types.h" #ifdef __GNUC__
#include "texture.h" # pragma GCC system_header
#include "mesh.h" #endif
#include "light.h"
#include "camera.h" #include <assimp/types.h>
#include "material.h" #include <assimp/texture.h>
#include "anim.h" #include <assimp/mesh.h>
#include "metadata.h" #include <assimp/light.h>
#include <assimp/camera.h>
#include <assimp/material.h>
#include <assimp/anim.h>
#include <assimp/metadata.h>
#ifdef __cplusplus #ifdef __cplusplus
# include <cstdlib> # include <cstdlib>

13
include/assimp/texture.h
View File

@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2019, assimp team Copyright (c) 2006-2019, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -53,13 +51,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_TEXTURE_H_INC #ifndef AI_TEXTURE_H_INC
#define AI_TEXTURE_H_INC #define AI_TEXTURE_H_INC
#include "types.h" #ifdef __GNUC__
# pragma GCC system_header
#endif
#include <assimp/types.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** \def AI_EMBEDDED_TEXNAME_PREFIX /** \def AI_EMBEDDED_TEXNAME_PREFIX
@ -79,7 +80,6 @@ extern "C" {
# define AI_MAKE_EMBEDDED_TEXNAME(_n_) AI_EMBEDDED_TEXNAME_PREFIX # _n_ # define AI_MAKE_EMBEDDED_TEXNAME(_n_) AI_EMBEDDED_TEXNAME_PREFIX # _n_
#endif #endif
#include "./Compiler/pushpack1.h" #include "./Compiler/pushpack1.h"
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
@ -87,8 +87,7 @@ extern "C" {
* *
* Used by aiTexture. * Used by aiTexture.
*/ */
struct aiTexel struct aiTexel {
{
unsigned char b,g,r,a; unsigned char b,g,r,a;
#ifdef __cplusplus #ifdef __cplusplus

21
include/assimp/types.h
View File

@ -48,6 +48,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_TYPES_H_INC #ifndef AI_TYPES_H_INC
#define AI_TYPES_H_INC #define AI_TYPES_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
// Some runtime headers // Some runtime headers
#include <sys/types.h> #include <sys/types.h>
#include <stddef.h> #include <stddef.h>
@ -56,15 +60,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <stdint.h> #include <stdint.h>
// Our compile configuration // Our compile configuration
#include "defs.h" #include <assimp/defs.h>
// Some types moved to separate header due to size of operators // Some types moved to separate header due to size of operators
#include "vector3.h" #include <assimp/vector3.h>
#include "vector2.h" #include <assimp/vector2.h>
#include "color4.h" #include <assimp/color4.h>
#include "matrix3x3.h" #include <assimp/matrix3x3.h>
#include "matrix4x4.h" #include <assimp/matrix4x4.h>
#include "quaternion.h" #include <assimp/quaternion.h>
typedef int32_t ai_int32; typedef int32_t ai_int32;
typedef uint32_t ai_uint32 ; typedef uint32_t ai_uint32 ;
@ -74,9 +78,8 @@ typedef uint32_t ai_uint32 ;
#include <new> // for std::nothrow_t #include <new> // for std::nothrow_t
#include <string> // for aiString::Set(const std::string&) #include <string> // for aiString::Set(const std::string&)
namespace Assimp { namespace Assimp {
//! @cond never //! @cond never
namespace Intern { namespace Intern {
// -------------------------------------------------------------------- // --------------------------------------------------------------------
/** @brief Internal helper class to utilize our internal new/delete /** @brief Internal helper class to utilize our internal new/delete

4
include/assimp/vector2.h
View File

@ -47,6 +47,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_VECTOR2D_H_INC #ifndef AI_VECTOR2D_H_INC
#define AI_VECTOR2D_H_INC #define AI_VECTOR2D_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#ifdef __cplusplus #ifdef __cplusplus
# include <cmath> # include <cmath>
#else #else

6
include/assimp/vector2.inl
View File

@ -48,8 +48,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_VECTOR2D_INL_INC #ifndef AI_VECTOR2D_INL_INC
#define AI_VECTOR2D_INL_INC #define AI_VECTOR2D_INL_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#ifdef __cplusplus #ifdef __cplusplus
#include "vector2.h" #include <assimp/vector2.h>
#include <cmath> #include <cmath>

12
include/assimp/vector3.h
View File

@ -47,13 +47,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_VECTOR3D_H_INC #ifndef AI_VECTOR3D_H_INC
#define AI_VECTOR3D_H_INC #define AI_VECTOR3D_H_INC
#ifdef __GNUC__
# pragma GCC system_header
#endif
#ifdef __cplusplus #ifdef __cplusplus
# include <cmath> # include <cmath>
#else #else
# include <math.h> # include <math.h>
#endif #endif
#include "defs.h" #include <assimp/defs.h>
#ifdef __cplusplus #ifdef __cplusplus
@ -63,16 +67,13 @@ template<typename TReal> class aiMatrix4x4t;
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Represents a three-dimensional vector. */ /** Represents a three-dimensional vector. */
template <typename TReal> template <typename TReal>
class aiVector3t class aiVector3t {
{
public: public:
aiVector3t() AI_NO_EXCEPT : x(), y(), z() {} aiVector3t() AI_NO_EXCEPT : x(), y(), z() {}
aiVector3t(TReal _x, TReal _y, TReal _z) : x(_x), y(_y), z(_z) {} aiVector3t(TReal _x, TReal _y, TReal _z) : x(_x), y(_y), z(_z) {}
explicit aiVector3t (TReal _xyz ) : x(_xyz), y(_xyz), z(_xyz) {} explicit aiVector3t (TReal _xyz ) : x(_xyz), y(_xyz), z(_xyz) {}
aiVector3t( const aiVector3t& o ) = default; aiVector3t( const aiVector3t& o ) = default;
public:
// combined operators // combined operators
const aiVector3t& operator += (const aiVector3t& o); const aiVector3t& operator += (const aiVector3t& o);
const aiVector3t& operator -= (const aiVector3t& o); const aiVector3t& operator -= (const aiVector3t& o);
@ -97,7 +98,6 @@ public:
template <typename TOther> template <typename TOther>
operator aiVector3t<TOther> () const; operator aiVector3t<TOther> () const;
public:
/** @brief Set the components of a vector /** @brief Set the components of a vector
* @param pX X component * @param pX X component
* @param pY Y component * @param pY Y component

2
include/assimp/vector3.inl
View File

@ -49,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define AI_VECTOR3D_INL_INC #define AI_VECTOR3D_INL_INC
#ifdef __cplusplus #ifdef __cplusplus
#include "vector3.h" #include <assimp/vector3.h>
#include <cmath> #include <cmath>

2
include/assimp/version.h
View File

@ -49,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_VERSION_H_INC #ifndef AI_VERSION_H_INC
#define AI_VERSION_H_INC #define AI_VERSION_H_INC
#include "defs.h" #include <assimp/defs.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {