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

Refactor: Use LF line endings

pull/566/head
Richard 2015-05-18 22:16:51 -06:00
parent 9d736cc1c5
commit 5dbd676c01
38 changed files with 12494 additions and 12495 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

380
include/assimp/DefaultLogger.hpp
View File

@ -1,190 +1,190 @@
/* /*
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
---------------------------------------------------------------------- ----------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the with or without modification, are permitted provided that the
following conditions are met: following conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
/** @file DefaultLogger.hpp /** @file DefaultLogger.hpp
*/ */
#ifndef INCLUDED_AI_DEFAULTLOGGER #ifndef INCLUDED_AI_DEFAULTLOGGER
#define INCLUDED_AI_DEFAULTLOGGER #define INCLUDED_AI_DEFAULTLOGGER
#include "Logger.hpp" #include "Logger.hpp"
#include "LogStream.hpp" #include "LogStream.hpp"
#include "NullLogger.hpp" #include "NullLogger.hpp"
#include <vector> #include <vector>
namespace Assimp { namespace Assimp {
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
class IOStream; class IOStream;
struct LogStreamInfo; struct LogStreamInfo;
/** default name of logfile */ /** default name of logfile */
#define ASSIMP_DEFAULT_LOG_NAME "AssimpLog.txt" #define ASSIMP_DEFAULT_LOG_NAME "AssimpLog.txt"
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
/** @brief CPP-API: Primary logging facility of Assimp. /** @brief CPP-API: Primary logging facility of Assimp.
* *
* The library stores its primary #Logger as a static member of this class. * The library stores its primary #Logger as a static member of this class.
* #get() returns this primary logger. By default the underlying implementation is * #get() returns this primary logger. By default the underlying implementation is
* just a #NullLogger which rejects all log messages. By calling #create(), logging * just a #NullLogger which rejects all log messages. By calling #create(), logging
* is turned on. To capture the log output multiple log streams (#LogStream) can be * is turned on. To capture the log output multiple log streams (#LogStream) can be
* attach to the logger. Some default streams for common streaming locations (such as * attach to the logger. Some default streams for common streaming locations (such as
* a file, std::cout, OutputDebugString()) are also provided. * a file, std::cout, OutputDebugString()) are also provided.
* *
* If you wish to customize the logging at an even deeper level supply your own * If you wish to customize the logging at an even deeper level supply your own
* implementation of #Logger to #set(). * implementation of #Logger to #set().
* @note The whole logging stuff causes a small extra overhead for all imports. */ * @note The whole logging stuff causes a small extra overhead for all imports. */
class ASSIMP_API DefaultLogger : class ASSIMP_API DefaultLogger :
public Logger { public Logger {
public: public:
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Creates a logging instance. /** @brief Creates a logging instance.
* @param name Name for log file. Only valid in combination * @param name Name for log file. Only valid in combination
* with the aiDefaultLogStream_FILE flag. * with the aiDefaultLogStream_FILE flag.
* @param severity Log severity, VERBOSE turns on debug messages * @param severity Log severity, VERBOSE turns on debug messages
* @param defStreams Default log streams to be attached. Any bitwise * @param defStreams Default log streams to be attached. Any bitwise
* combination of the aiDefaultLogStream enumerated values. * combination of the aiDefaultLogStream enumerated values.
* If #aiDefaultLogStream_FILE is specified but an empty string is * If #aiDefaultLogStream_FILE is specified but an empty string is
* passed for 'name', no log file is created at all. * passed for 'name', no log file is created at all.
* @param io IOSystem to be used to open external files (such as the * @param io IOSystem to be used to open external files (such as the
* log file). Pass NULL to rely on the default implementation. * log file). Pass NULL to rely on the default implementation.
* This replaces the default #NullLogger with a #DefaultLogger instance. */ * This replaces the default #NullLogger with a #DefaultLogger instance. */
static Logger *create(const char* name = ASSIMP_DEFAULT_LOG_NAME, static Logger *create(const char* name = ASSIMP_DEFAULT_LOG_NAME,
LogSeverity severity = NORMAL, LogSeverity severity = NORMAL,
unsigned int defStreams = aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE, unsigned int defStreams = aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE,
IOSystem* io = NULL); IOSystem* io = NULL);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Setup a custom #Logger implementation. /** @brief Setup a custom #Logger implementation.
* *
* Use this if the provided #DefaultLogger class doesn't fit into * Use this if the provided #DefaultLogger class doesn't fit into
* your needs. If the provided message formatting is OK for you, * your needs. If the provided message formatting is OK for you,
* it's much easier to use #create() and to attach your own custom * it's much easier to use #create() and to attach your own custom
* output streams to it. * output streams to it.
* @param logger Pass NULL to setup a default NullLogger*/ * @param logger Pass NULL to setup a default NullLogger*/
static void set (Logger *logger); static void set (Logger *logger);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Getter for singleton instance /** @brief Getter for singleton instance
* @return Only instance. This is never null, but it could be a * @return Only instance. This is never null, but it could be a
* NullLogger. Use isNullLogger to check this.*/ * NullLogger. Use isNullLogger to check this.*/
static Logger *get(); static Logger *get();
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Return whether a #NullLogger is currently active /** @brief Return whether a #NullLogger is currently active
* @return true if the current logger is a #NullLogger. * @return true if the current logger is a #NullLogger.
* Use create() or set() to setup a logger that does actually do * Use create() or set() to setup a logger that does actually do
* something else than just rejecting all log messages. */ * something else than just rejecting all log messages. */
static bool isNullLogger(); static bool isNullLogger();
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Kills the current singleton logger and replaces it with a /** @brief Kills the current singleton logger and replaces it with a
* #NullLogger instance. */ * #NullLogger instance. */
static void kill(); static void kill();
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @copydoc Logger::attachStream */ /** @copydoc Logger::attachStream */
bool attachStream(LogStream *pStream, bool attachStream(LogStream *pStream,
unsigned int severity); unsigned int severity);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @copydoc Logger::detatchStream */ /** @copydoc Logger::detatchStream */
bool detatchStream(LogStream *pStream, bool detatchStream(LogStream *pStream,
unsigned int severity); unsigned int severity);
private: private:
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @briefPrivate construction for internal use by create(). /** @briefPrivate construction for internal use by create().
* @param severity Logging granularity */ * @param severity Logging granularity */
DefaultLogger(LogSeverity severity); DefaultLogger(LogSeverity severity);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @briefDestructor */ /** @briefDestructor */
~DefaultLogger(); ~DefaultLogger();
private: private:
/** @brief Logs debug infos, only been written when severity level VERBOSE is set */ /** @brief Logs debug infos, only been written when severity level VERBOSE is set */
void OnDebug(const char* message); void OnDebug(const char* message);
/** @brief Logs an info message */ /** @brief Logs an info message */
void OnInfo(const char* message); void OnInfo(const char* message);
/** @brief Logs a warning message */ /** @brief Logs a warning message */
void OnWarn(const char* message); void OnWarn(const char* message);
/** @brief Logs an error message */ /** @brief Logs an error message */
void OnError(const char* message); void OnError(const char* message);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Writes a message to all streams */ /** @brief Writes a message to all streams */
void WriteToStreams(const char* message, ErrorSeverity ErrorSev ); void WriteToStreams(const char* message, ErrorSeverity ErrorSev );
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Returns the thread id. /** @brief Returns the thread id.
* @note This is an OS specific feature, if not supported, a * @note This is an OS specific feature, if not supported, a
* zero will be returned. * zero will be returned.
*/ */
unsigned int GetThreadID(); unsigned int GetThreadID();
private: private:
// Aliases for stream container // Aliases for stream container
typedef std::vector<LogStreamInfo*> StreamArray; typedef std::vector<LogStreamInfo*> StreamArray;
typedef std::vector<LogStreamInfo*>::iterator StreamIt; typedef std::vector<LogStreamInfo*>::iterator StreamIt;
typedef std::vector<LogStreamInfo*>::const_iterator ConstStreamIt; typedef std::vector<LogStreamInfo*>::const_iterator ConstStreamIt;
//! only logging instance //! only logging instance
static Logger *m_pLogger; static Logger *m_pLogger;
static NullLogger s_pNullLogger; static NullLogger s_pNullLogger;
//! Attached streams //! Attached streams
StreamArray m_StreamArray; StreamArray m_StreamArray;
bool noRepeatMsg; bool noRepeatMsg;
char lastMsg[MAX_LOG_MESSAGE_LENGTH*2]; char lastMsg[MAX_LOG_MESSAGE_LENGTH*2];
size_t lastLen; size_t lastLen;
}; };
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
} // Namespace Assimp } // Namespace Assimp
#endif // !! INCLUDED_AI_DEFAULTLOGGER #endif // !! INCLUDED_AI_DEFAULTLOGGER

1009
include/assimp/Exporter.hpp
View File

File diff suppressed because it is too large Load Diff

276
include/assimp/IOStream.hpp
View File

@ -1,138 +1,138 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file IOStream.hpp /** @file IOStream.hpp
* @brief File I/O wrappers for C++. * @brief File I/O wrappers for C++.
*/ */
#ifndef AI_IOSTREAM_H_INC #ifndef AI_IOSTREAM_H_INC
#define AI_IOSTREAM_H_INC #define AI_IOSTREAM_H_INC
#include "types.h" #include "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++
* *
* Derive an own implementation from this interface to provide custom IO handling * Derive an own implementation from this interface to provide custom IO handling
* to the Importer. If you implement this interface, be sure to also provide an * to the Importer. If you implement this interface, be sure to also provide an
* implementation for IOSystem that creates instances of your custom IO class. * implementation for IOSystem that creates instances of your custom IO class.
*/ */
class ASSIMP_API IOStream class ASSIMP_API IOStream
#ifndef SWIG #ifndef SWIG
: public Intern::AllocateFromAssimpHeap : public Intern::AllocateFromAssimpHeap
#endif #endif
{ {
protected: protected:
/** Constructor protected, use IOSystem::Open() to create an instance. */ /** Constructor protected, use IOSystem::Open() to create an instance. */
IOStream(void); IOStream(void);
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Destructor. Deleting the object closes the underlying file, /** @brief Destructor. Deleting the object closes the underlying file,
* alternatively you may use IOSystem::Close() to release the file. * alternatively you may use IOSystem::Close() to release the file.
*/ */
virtual ~IOStream(); virtual ~IOStream();
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Read from the file /** @brief Read from the file
* *
* See fread() for more details * See fread() for more details
* This fails for write-only files */ * This fails for write-only files */
virtual size_t Read(void* pvBuffer, virtual size_t Read(void* pvBuffer,
size_t pSize, size_t pSize,
size_t pCount) = 0; size_t pCount) = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Write to the file /** @brief Write to the file
* *
* See fwrite() for more details * See fwrite() for more details
* This fails for read-only files */ * This fails for read-only files */
virtual size_t Write(const void* pvBuffer, virtual size_t Write(const void* pvBuffer,
size_t pSize, size_t pSize,
size_t pCount) = 0; size_t pCount) = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Set the read/write cursor of the file /** @brief Set the read/write cursor of the file
* *
* Note that the offset is _negative_ for aiOrigin_END. * Note that the offset is _negative_ for aiOrigin_END.
* See fseek() for more details */ * See fseek() for more details */
virtual aiReturn Seek(size_t pOffset, virtual aiReturn Seek(size_t pOffset,
aiOrigin pOrigin) = 0; aiOrigin pOrigin) = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Get the current position of the read/write cursor /** @brief Get the current position of the read/write cursor
* *
* See ftell() for more details */ * See ftell() for more details */
virtual size_t Tell() const = 0; virtual size_t Tell() const = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns filesize /** @brief Returns filesize
* Returns the filesize. */ * Returns the filesize. */
virtual size_t FileSize() const = 0; virtual size_t FileSize() const = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Flush the contents of the file buffer (for writers) /** @brief Flush the contents of the file buffer (for writers)
* See fflush() for more details. * See fflush() for more details.
*/ */
virtual void Flush() = 0; virtual void Flush() = 0;
}; //! class IOStream }; //! class IOStream
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline IOStream::IOStream() inline IOStream::IOStream()
{ {
// empty // empty
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline IOStream::~IOStream() inline IOStream::~IOStream()
{ {
// empty // empty
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
} //!namespace Assimp } //!namespace Assimp
#endif //!!AI_IOSTREAM_H_INC #endif //!!AI_IOSTREAM_H_INC

450
include/assimp/IOSystem.hpp
View File

@ -1,225 +1,225 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file IOSystem.hpp /** @file IOSystem.hpp
* @brief File system wrapper for C++. Inherit this class to supply * @brief File system wrapper for C++. Inherit this class to supply
* custom file handling logic to the Import library. * custom file handling logic to the Import library.
*/ */
#ifndef AI_IOSYSTEM_H_INC #ifndef AI_IOSYSTEM_H_INC
#define AI_IOSYSTEM_H_INC #define AI_IOSYSTEM_H_INC
#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
#include "types.h" #include "types.h"
namespace Assimp { namespace Assimp {
class IOStream; class IOStream;
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief CPP-API: Interface to the file system. /** @brief CPP-API: Interface to the file system.
* *
* Derive an own implementation from this interface to supply custom file handling * Derive an own implementation from this interface to supply custom file handling
* to the importer library. If you implement this interface, you also want to * to the importer library. If you implement this interface, you also want to
* supply a custom implementation for IOStream. * supply a custom implementation for IOStream.
* *
* @see Importer::SetIOHandler() */ * @see Importer::SetIOHandler() */
class ASSIMP_API IOSystem class ASSIMP_API IOSystem
#ifndef SWIG #ifndef SWIG
: public Intern::AllocateFromAssimpHeap : public Intern::AllocateFromAssimpHeap
#endif #endif
{ {
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Default constructor. /** @brief Default constructor.
* *
* Create an instance of your derived class and assign it to an * Create an instance of your derived class and assign it to an
* #Assimp::Importer instance by calling Importer::SetIOHandler(). * #Assimp::Importer instance by calling Importer::SetIOHandler().
*/ */
IOSystem(); IOSystem();
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Virtual destructor. /** @brief Virtual destructor.
* *
* It is safe to be called from within DLL Assimp, we're constructed * It is safe to be called from within DLL Assimp, we're constructed
* on Assimp's heap. * on Assimp's heap.
*/ */
virtual ~IOSystem(); virtual ~IOSystem();
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief For backward compatibility /** @brief For backward compatibility
* @see Exists(const char*) * @see Exists(const char*)
*/ */
AI_FORCE_INLINE bool Exists( const std::string& pFile) const; AI_FORCE_INLINE bool Exists( const std::string& pFile) const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Tests for the existence of a file at the given path. /** @brief Tests for the existence of a file at the given path.
* *
* @param pFile Path to the file * @param pFile Path to the file
* @return true if there is a file with this path, else false. * @return true if there is a file with this path, else false.
*/ */
virtual bool Exists( const char* pFile) const = 0; virtual bool Exists( const char* pFile) const = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns the system specific directory separator /** @brief Returns the system specific directory separator
* @return System specific directory separator * @return System specific directory separator
*/ */
virtual char getOsSeparator() const = 0; virtual char getOsSeparator() const = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Open a new file with a given path. /** @brief Open a new file with a given path.
* *
* When the access to the file is finished, call Close() to release * When the access to the file is finished, call Close() to release
* all associated resources (or the virtual dtor of the IOStream). * all associated resources (or the virtual dtor of the IOStream).
* *
* @param pFile Path to the file * @param pFile Path to the file
* @param pMode Desired file I/O mode. Required are: "wb", "w", "wt", * @param pMode Desired file I/O mode. Required are: "wb", "w", "wt",
* "rb", "r", "rt". * "rb", "r", "rt".
* *
* @return New IOStream interface allowing the lib to access * @return New IOStream interface allowing the lib to access
* the underlying file. * the underlying file.
* @note When implementing this class to provide custom IO handling, * @note When implementing this class to provide custom IO handling,
* you probably have to supply an own implementation of IOStream as well. * you probably have to supply an own implementation of IOStream as well.
*/ */
virtual IOStream* Open(const char* pFile, virtual IOStream* Open(const char* pFile,
const char* pMode = "rb") = 0; const char* pMode = "rb") = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief For backward compatibility /** @brief For backward compatibility
* @see Open(const char*, const char*) * @see Open(const char*, const char*)
*/ */
inline IOStream* Open(const std::string& pFile, inline IOStream* Open(const std::string& pFile,
const std::string& pMode = std::string("rb")); const std::string& pMode = std::string("rb"));
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Closes the given file and releases all resources /** @brief Closes the given file and releases all resources
* associated with it. * associated with it.
* @param pFile The file instance previously created by Open(). * @param pFile The file instance previously created by Open().
*/ */
virtual void Close( IOStream* pFile) = 0; virtual void Close( IOStream* pFile) = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Compares two paths and check whether the point to /** @brief Compares two paths and check whether the point to
* identical files. * identical files.
* *
* The dummy implementation of this virtual member performs a * The dummy implementation of this virtual member performs a
* case-insensitive comparison of the given strings. The default IO * case-insensitive comparison of the given strings. The default IO
* system implementation uses OS mechanisms to convert relative into * system implementation uses OS mechanisms to convert relative into
* absolute paths, so the result can be trusted. * absolute paths, so the result can be trusted.
* @param one First file * @param one First file
* @param second Second file * @param second Second file
* @return true if the paths point to the same file. The file needn't * @return true if the paths point to the same file. The file needn't
* be existing, however. * be existing, however.
*/ */
virtual bool ComparePaths (const char* one, virtual bool ComparePaths (const char* one,
const char* second) const; const char* second) const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief For backward compatibility /** @brief For backward compatibility
* @see ComparePaths(const char*, const char*) * @see ComparePaths(const char*, const char*)
*/ */
inline bool ComparePaths (const std::string& one, inline bool ComparePaths (const std::string& one,
const std::string& second) const; const std::string& second) const;
}; };
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
AI_FORCE_INLINE IOSystem::IOSystem() AI_FORCE_INLINE IOSystem::IOSystem()
{ {
// empty // empty
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
AI_FORCE_INLINE IOSystem::~IOSystem() AI_FORCE_INLINE IOSystem::~IOSystem()
{ {
// empty // empty
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// For compatibility, the interface of some functions taking a std::string was // For compatibility, the interface of some functions taking a std::string was
// changed to const char* to avoid crashes between binary incompatible STL // changed to const char* to avoid crashes between binary incompatible STL
// versions. This code her is inlined, so it shouldn't cause any problems. // versions. This code her is inlined, so it shouldn't cause any problems.
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
AI_FORCE_INLINE IOStream* IOSystem::Open(const std::string& pFile, AI_FORCE_INLINE IOStream* IOSystem::Open(const std::string& pFile,
const std::string& pMode) const std::string& pMode)
{ {
// NOTE: // NOTE:
// For compatibility, interface was changed to const char* to // For compatibility, interface was changed to const char* to
// avoid crashes between binary incompatible STL versions // avoid crashes between binary incompatible STL versions
return Open(pFile.c_str(),pMode.c_str()); return Open(pFile.c_str(),pMode.c_str());
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
AI_FORCE_INLINE bool IOSystem::Exists( const std::string& pFile) const AI_FORCE_INLINE bool IOSystem::Exists( const std::string& pFile) const
{ {
// NOTE: // NOTE:
// For compatibility, interface was changed to const char* to // For compatibility, interface was changed to const char* to
// avoid crashes between binary incompatible STL versions // avoid crashes between binary incompatible STL versions
return Exists(pFile.c_str()); return Exists(pFile.c_str());
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
inline bool IOSystem::ComparePaths (const std::string& one, inline bool IOSystem::ComparePaths (const std::string& one,
const std::string& second) const const std::string& second) const
{ {
// NOTE: // NOTE:
// For compatibility, interface was changed to const char* to // For compatibility, interface was changed to const char* to
// avoid crashes between binary incompatible STL versions // avoid crashes between binary incompatible STL versions
return ComparePaths(one.c_str(),second.c_str()); return ComparePaths(one.c_str(),second.c_str());
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
} //!ns Assimp } //!ns Assimp
#endif //AI_IOSYSTEM_H_INC #endif //AI_IOSYSTEM_H_INC

1308
include/assimp/Importer.hpp
View File

File diff suppressed because it is too large Load Diff

192
include/assimp/LogStream.hpp
View File

@ -1,96 +1,96 @@
/* /*
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
---------------------------------------------------------------------- ----------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the with or without modification, are permitted provided that the
following conditions are met: following conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
/** @file LogStream.hpp /** @file LogStream.hpp
* @brief Abstract base class 'LogStream', representing an output log stream. * @brief Abstract base class 'LogStream', representing an output log stream.
*/ */
#ifndef INCLUDED_AI_LOGSTREAM_H #ifndef INCLUDED_AI_LOGSTREAM_H
#define INCLUDED_AI_LOGSTREAM_H #define INCLUDED_AI_LOGSTREAM_H
#include "types.h" #include "types.h"
namespace Assimp { namespace Assimp {
class IOSystem; class IOSystem;
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
/** @brief CPP-API: Abstract interface for log stream implementations. /** @brief CPP-API: Abstract interface for log stream implementations.
* *
* Several default implementations are provided, see #aiDefaultLogStream for more * Several default implementations are provided, see #aiDefaultLogStream for more
* details. Writing your own implementation of LogStream is just necessary if these * details. Writing your own implementation of LogStream is just necessary if these
* are not enough for your purpose. */ * are not enough for your purpose. */
class ASSIMP_API LogStream class ASSIMP_API LogStream
#ifndef SWIG #ifndef SWIG
: public Intern::AllocateFromAssimpHeap : public Intern::AllocateFromAssimpHeap
#endif #endif
{ {
protected: protected:
/** @brief Default constructor */ /** @brief Default constructor */
LogStream() { LogStream() {
} }
public: public:
/** @brief Virtual destructor */ /** @brief Virtual destructor */
virtual ~LogStream() { virtual ~LogStream() {
} }
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Overwrite this for your own output methods /** @brief Overwrite this for your own output methods
* *
* Log messages *may* consist of multiple lines and you shouldn't * Log messages *may* consist of multiple lines and you shouldn't
* expect a consistent formatting. If you want custom formatting * expect a consistent formatting. If you want custom formatting
* (e.g. generate HTML), supply a custom instance of Logger to * (e.g. generate HTML), supply a custom instance of Logger to
* #DefaultLogger:set(). Usually you can *expect* that a log message * #DefaultLogger:set(). Usually you can *expect* that a log message
* is exactly one line and terminated with a single \n character. * is exactly one line and terminated with a single \n character.
* @param message Message to be written */ * @param message Message to be written */
virtual void write(const char* message) = 0; virtual void write(const char* message) = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Creates a default log stream /** @brief Creates a default log stream
* @param streams Type of the default stream * @param streams Type of the default stream
* @param name For aiDefaultLogStream_FILE: name of the output file * @param name For aiDefaultLogStream_FILE: name of the output file
* @param io For aiDefaultLogStream_FILE: IOSystem to be used to open the output * @param io For aiDefaultLogStream_FILE: IOSystem to be used to open the output
* file. Pass NULL for the default implementation. * file. Pass NULL for the default implementation.
* @return New LogStream instance. */ * @return New LogStream instance. */
static LogStream* createDefaultStream(aiDefaultLogStream stream, static LogStream* createDefaultStream(aiDefaultLogStream stream,
const char* name = "AssimpLog.txt", const char* name = "AssimpLog.txt",
IOSystem* io = NULL); IOSystem* io = NULL);
}; // !class LogStream }; // !class LogStream
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
} // Namespace Assimp } // Namespace Assimp
#endif #endif

530
include/assimp/Logger.hpp
View File

@ -1,265 +1,265 @@
/* /*
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
---------------------------------------------------------------------- ----------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the with or without modification, are permitted provided that the
following conditions are met: following conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
/** @file Logger.hpp /** @file Logger.hpp
* @brief Abstract base class 'Logger', base of the logging system. * @brief Abstract base class 'Logger', base of the logging system.
*/ */
#ifndef INCLUDED_AI_LOGGER_H #ifndef INCLUDED_AI_LOGGER_H
#define INCLUDED_AI_LOGGER_H #define INCLUDED_AI_LOGGER_H
#include "types.h" #include "types.h"
namespace Assimp { namespace Assimp {
class LogStream; class LogStream;
// Maximum length of a log message. Longer messages are rejected. // Maximum length of a log message. Longer messages are rejected.
#define MAX_LOG_MESSAGE_LENGTH 1024u #define MAX_LOG_MESSAGE_LENGTH 1024u
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
/** @brief CPP-API: Abstract interface for logger implementations. /** @brief CPP-API: Abstract interface for logger implementations.
* Assimp provides a default implementation and uses it for almost all * Assimp provides a default implementation and uses it for almost all
* logging stuff ('DefaultLogger'). This class defines just basic logging * logging stuff ('DefaultLogger'). This class defines just basic logging
* behaviour and is not of interest for you. Instead, take a look at #DefaultLogger. */ * behaviour and is not of interest for you. Instead, take a look at #DefaultLogger. */
class ASSIMP_API Logger class ASSIMP_API Logger
#ifndef SWIG #ifndef SWIG
: public Intern::AllocateFromAssimpHeap : public Intern::AllocateFromAssimpHeap
#endif #endif
{ {
public: public:
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @enum LogSeverity /** @enum LogSeverity
* @brief Log severity to describe the granularity of logging. * @brief Log severity to describe the granularity of logging.
*/ */
enum LogSeverity enum LogSeverity
{ {
NORMAL, //!< Normal granularity of logging NORMAL, //!< Normal granularity of logging
VERBOSE //!< Debug infos will be logged, too VERBOSE //!< Debug infos will be logged, too
}; };
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @enum ErrorSeverity /** @enum ErrorSeverity
* @brief Description for severity of a log message. * @brief Description for severity of a log message.
* *
* Every LogStream has a bitwise combination of these flags. * Every LogStream has a bitwise combination of these flags.
* A LogStream doesn't receive any messages of a specific type * A LogStream doesn't receive any messages of a specific type
* if it doesn't specify the corresponding ErrorSeverity flag. * if it doesn't specify the corresponding ErrorSeverity flag.
*/ */
enum ErrorSeverity enum ErrorSeverity
{ {
Debugging = 1, //!< Debug log message Debugging = 1, //!< Debug log message
Info = 2, //!< Info log message Info = 2, //!< Info log message
Warn = 4, //!< Warn log message Warn = 4, //!< Warn log message
Err = 8 //!< Error log message Err = 8 //!< Error log message
}; };
public: public:
/** @brief Virtual destructor */ /** @brief Virtual destructor */
virtual ~Logger(); virtual ~Logger();
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Writes a debug message /** @brief Writes a debug message
* @param message Debug message*/ * @param message Debug message*/
void debug(const char* message); void debug(const char* message);
inline void debug(const std::string &message); inline void debug(const std::string &message);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Writes a info message /** @brief Writes a info message
* @param message Info message*/ * @param message Info message*/
void info(const char* message); void info(const char* message);
inline void info(const std::string &message); inline void info(const std::string &message);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Writes a warning message /** @brief Writes a warning message
* @param message Warn message*/ * @param message Warn message*/
void warn(const char* message); void warn(const char* message);
inline void warn(const std::string &message); inline void warn(const std::string &message);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Writes an error message /** @brief Writes an error message
* @param message Error message*/ * @param message Error message*/
void error(const char* message); void error(const char* message);
inline void error(const std::string &message); inline void error(const std::string &message);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Set a new log severity. /** @brief Set a new log severity.
* @param log_severity New severity for logging*/ * @param log_severity New severity for logging*/
void setLogSeverity(LogSeverity log_severity); void setLogSeverity(LogSeverity log_severity);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Get the current log severity*/ /** @brief Get the current log severity*/
LogSeverity getLogSeverity() const; LogSeverity getLogSeverity() const;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Attach a new log-stream /** @brief Attach a new log-stream
* *
* The logger takes ownership of the stream and is responsible * The logger takes ownership of the stream and is responsible
* for its destruction (which is done using ::delete when the logger * for its destruction (which is done using ::delete when the logger
* itself is destroyed). Call detachStream to detach a stream and to * itself is destroyed). Call detachStream to detach a stream and to
* gain ownership of it again. * gain ownership of it again.
* @param pStream Log-stream to attach * @param pStream Log-stream to attach
* @param severity Message filter, specified which types of log * @param severity Message filter, specified which types of log
* messages are dispatched to the stream. Provide a bitwise * messages are dispatched to the stream. Provide a bitwise
* combination of the ErrorSeverity flags. * combination of the ErrorSeverity flags.
* @return true if the stream has been attached, false otherwise.*/ * @return true if the stream has been attached, false otherwise.*/
virtual bool attachStream(LogStream *pStream, virtual bool attachStream(LogStream *pStream,
unsigned int severity = Debugging | Err | Warn | Info) = 0; unsigned int severity = Debugging | Err | Warn | Info) = 0;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Detach a still attached stream from the logger (or /** @brief Detach a still attached stream from the logger (or
* modify the filter flags bits) * modify the filter flags bits)
* @param pStream Log-stream instance for detaching * @param pStream Log-stream instance for detaching
* @param severity Provide a bitwise combination of the ErrorSeverity * @param severity Provide a bitwise combination of the ErrorSeverity
* flags. This value is &~ed with the current flags of the stream, * flags. This value is &~ed with the current flags of the stream,
* if the result is 0 the stream is detached from the Logger and * if the result is 0 the stream is detached from the Logger and
* the caller retakes the possession of the stream. * the caller retakes the possession of the stream.
* @return true if the stream has been detached, false otherwise.*/ * @return true if the stream has been detached, false otherwise.*/
virtual bool detatchStream(LogStream *pStream, virtual bool detatchStream(LogStream *pStream,
unsigned int severity = Debugging | Err | Warn | Info) = 0; unsigned int severity = Debugging | Err | Warn | Info) = 0;
protected: protected:
/** Default constructor */ /** Default constructor */
Logger(); Logger();
/** Construction with a given log severity */ /** Construction with a given log severity */
Logger(LogSeverity severity); Logger(LogSeverity severity);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Called as a request to write a specific debug message /** @brief Called as a request to write a specific debug message
* @param message Debug message. Never longer than * @param message Debug message. Never longer than
* MAX_LOG_MESSAGE_LENGTH characters (excluding the '0'). * MAX_LOG_MESSAGE_LENGTH characters (excluding the '0').
* @note The message string is only valid until the scope of * @note The message string is only valid until the scope of
* the function is left. * the function is left.
*/ */
virtual void OnDebug(const char* message)= 0; virtual void OnDebug(const char* message)= 0;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Called as a request to write a specific info message /** @brief Called as a request to write a specific info message
* @param message Info message. Never longer than * @param message Info message. Never longer than
* MAX_LOG_MESSAGE_LENGTH characters (ecxluding the '0'). * MAX_LOG_MESSAGE_LENGTH characters (ecxluding the '0').
* @note The message string is only valid until the scope of * @note The message string is only valid until the scope of
* the function is left. * the function is left.
*/ */
virtual void OnInfo(const char* message) = 0; virtual void OnInfo(const char* message) = 0;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Called as a request to write a specific warn message /** @brief Called as a request to write a specific warn message
* @param message Warn message. Never longer than * @param message Warn message. Never longer than
* MAX_LOG_MESSAGE_LENGTH characters (exluding the '0'). * MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
* @note The message string is only valid until the scope of * @note The message string is only valid until the scope of
* the function is left. * the function is left.
*/ */
virtual void OnWarn(const char* essage) = 0; virtual void OnWarn(const char* essage) = 0;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Called as a request to write a specific error message /** @brief Called as a request to write a specific error message
* @param message Error message. Never longer than * @param message Error message. Never longer than
* MAX_LOG_MESSAGE_LENGTH characters (exluding the '0'). * MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
* @note The message string is only valid until the scope of * @note The message string is only valid until the scope of
* the function is left. * the function is left.
*/ */
virtual void OnError(const char* message) = 0; virtual void OnError(const char* message) = 0;
protected: protected:
//! Logger severity //! Logger severity
LogSeverity m_Severity; LogSeverity m_Severity;
}; };
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
// Default constructor // Default constructor
inline Logger::Logger() { inline Logger::Logger() {
setLogSeverity(NORMAL); setLogSeverity(NORMAL);
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
// Virtual destructor // Virtual destructor
inline Logger::~Logger() inline Logger::~Logger()
{ {
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
// Construction with given logging severity // Construction with given logging severity
inline Logger::Logger(LogSeverity severity) { inline Logger::Logger(LogSeverity severity) {
setLogSeverity(severity); setLogSeverity(severity);
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
// Log severity setter // Log severity setter
inline void Logger::setLogSeverity(LogSeverity log_severity){ inline void Logger::setLogSeverity(LogSeverity log_severity){
m_Severity = log_severity; m_Severity = log_severity;
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
// Log severity getter // Log severity getter
inline Logger::LogSeverity Logger::getLogSeverity() const { inline Logger::LogSeverity Logger::getLogSeverity() const {
return m_Severity; return m_Severity;
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline void Logger::debug(const std::string &message) inline void Logger::debug(const std::string &message)
{ {
return debug(message.c_str()); return debug(message.c_str());
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline void Logger::error(const std::string &message) inline void Logger::error(const std::string &message)
{ {
return error(message.c_str()); return error(message.c_str());
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline void Logger::warn(const std::string &message) inline void Logger::warn(const std::string &message)
{ {
return warn(message.c_str()); return warn(message.c_str());
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline void Logger::info(const std::string &message) inline void Logger::info(const std::string &message)
{ {
return info(message.c_str()); return info(message.c_str());
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
} // Namespace Assimp } // Namespace Assimp
#endif // !! INCLUDED_AI_LOGGER_H #endif // !! INCLUDED_AI_LOGGER_H

190
include/assimp/NullLogger.hpp
View File

@ -1,95 +1,95 @@
/* /*
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
---------------------------------------------------------------------- ----------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the with or without modification, are permitted provided that the
following conditions are met: following conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
/** @file NullLogger.hpp /** @file NullLogger.hpp
* @brief Dummy logger * @brief Dummy logger
*/ */
#ifndef INCLUDED_AI_NULLLOGGER_H #ifndef INCLUDED_AI_NULLLOGGER_H
#define INCLUDED_AI_NULLLOGGER_H #define INCLUDED_AI_NULLLOGGER_H
#include "Logger.hpp" #include "Logger.hpp"
namespace Assimp { namespace Assimp {
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief CPP-API: Empty logging implementation. /** @brief CPP-API: Empty logging implementation.
* *
* Does nothing! Used by default if the application hasn't requested a * Does nothing! Used by default if the application hasn't requested a
* custom logger via #DefaultLogger::set() or #DefaultLogger::create(); */ * custom logger via #DefaultLogger::set() or #DefaultLogger::create(); */
class ASSIMP_API NullLogger class ASSIMP_API NullLogger
: public Logger { : public Logger {
public: public:
/** @brief Logs a debug message */ /** @brief Logs a debug message */
void OnDebug(const char* message) { void OnDebug(const char* message) {
(void)message; //this avoids compiler warnings (void)message; //this avoids compiler warnings
} }
/** @brief Logs an info message */ /** @brief Logs an info message */
void OnInfo(const char* message) { void OnInfo(const char* message) {
(void)message; //this avoids compiler warnings (void)message; //this avoids compiler warnings
} }
/** @brief Logs a warning message */ /** @brief Logs a warning message */
void OnWarn(const char* message) { void OnWarn(const char* message) {
(void)message; //this avoids compiler warnings (void)message; //this avoids compiler warnings
} }
/** @brief Logs an error message */ /** @brief Logs an error message */
void OnError(const char* message) { void OnError(const char* message) {
(void)message; //this avoids compiler warnings (void)message; //this avoids compiler warnings
} }
/** @brief Detach a still attached stream from logger */ /** @brief Detach a still attached stream from logger */
bool attachStream(LogStream *pStream, unsigned int severity) { bool attachStream(LogStream *pStream, unsigned int severity) {
(void)pStream; (void)severity; //this avoids compiler warnings (void)pStream; (void)severity; //this avoids compiler warnings
return false; return false;
} }
/** @brief Detach a still attached stream from logger */ /** @brief Detach a still attached stream from logger */
bool detatchStream(LogStream *pStream, unsigned int severity) { bool detatchStream(LogStream *pStream, unsigned int severity) {
(void)pStream; (void)severity; //this avoids compiler warnings (void)pStream; (void)severity; //this avoids compiler warnings
return false; return false;
} }
private: private:
}; };
} }
#endif // !! AI_NULLLOGGER_H_INCLUDED #endif // !! AI_NULLLOGGER_H_INCLUDED

244
include/assimp/ProgressHandler.hpp
View File

@ -1,122 +1,122 @@
/* /*
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
---------------------------------------------------------------------- ----------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the with or without modification, are permitted provided that the
following conditions are met: following conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
/** @file ProgressHandler.hpp /** @file ProgressHandler.hpp
* @brief Abstract base class 'ProgressHandler'. * @brief Abstract base class 'ProgressHandler'.
*/ */
#ifndef INCLUDED_AI_PROGRESSHANDLER_H #ifndef INCLUDED_AI_PROGRESSHANDLER_H
#define INCLUDED_AI_PROGRESSHANDLER_H #define INCLUDED_AI_PROGRESSHANDLER_H
#include "types.h" #include "types.h"
namespace Assimp { namespace Assimp {
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
/** @brief CPP-API: Abstract interface for custom progress report receivers. /** @brief CPP-API: Abstract interface for custom progress report receivers.
* *
* Each #Importer instance maintains its own #ProgressHandler. The default * Each #Importer instance maintains its own #ProgressHandler. The default
* implementation provided by Assimp doesn't do anything at all. */ * implementation provided by Assimp doesn't do anything at all. */
class ASSIMP_API ProgressHandler class ASSIMP_API ProgressHandler
#ifndef SWIG #ifndef SWIG
: public Intern::AllocateFromAssimpHeap : public Intern::AllocateFromAssimpHeap
#endif #endif
{ {
protected: protected:
/** @brief Default constructor */ /** @brief Default constructor */
ProgressHandler () { ProgressHandler () {
} }
public: public:
/** @brief Virtual destructor */ /** @brief Virtual destructor */
virtual ~ProgressHandler () { virtual ~ProgressHandler () {
} }
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Progress callback. /** @brief Progress callback.
* @param percentage An estimate of the current loading progress, * @param percentage An estimate of the current loading progress,
* in percent. Or -1.f if such an estimate is not available. * in percent. Or -1.f if such an estimate is not available.
* *
* There are restriction on what you may do from within your * There are restriction on what you may do from within your
* implementation of this method: no exceptions may be thrown and no * implementation of this method: no exceptions may be thrown and no
* non-const #Importer methods may be called. It is * non-const #Importer methods may be called. It is
* not generally possible to predict the number of callbacks * not generally possible to predict the number of callbacks
* fired during a single import. * fired during a single import.
* *
* @return Return false to abort loading at the next possible * @return Return false to abort loading at the next possible
* occasion (loaders and Assimp are generally allowed to perform * occasion (loaders and Assimp are generally allowed to perform
* all needed cleanup tasks prior to returning control to the * all needed cleanup tasks prior to returning control to the
* caller). If the loading is aborted, #Importer::ReadFile() * caller). If the loading is aborted, #Importer::ReadFile()
* returns always NULL. * returns always NULL.
* */ * */
virtual bool Update(float percentage = -1.f) = 0; virtual bool Update(float percentage = -1.f) = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Progress callback for file loading steps /** @brief Progress callback for file loading steps
* @param numberOfSteps The number of total post-processing * @param numberOfSteps The number of total post-processing
* steps * steps
* @param currentStep The index of the current post-processing * @param currentStep The index of the current post-processing
* step that will run, or equal to numberOfSteps if all of * step that will run, or equal to numberOfSteps if all of
* them has finished. This number is always strictly monotone * them has finished. This number is always strictly monotone
* increasing, although not necessarily linearly. * increasing, although not necessarily linearly.
* *
* @note This is currently only used at the start and the end * @note This is currently only used at the start and the end
* of the file parsing. * of the file parsing.
* */ * */
virtual void UpdateFileRead(int currentStep /*= 0*/, int numberOfSteps /*= 0*/) { virtual void UpdateFileRead(int currentStep /*= 0*/, int numberOfSteps /*= 0*/) {
float f = numberOfSteps ? currentStep / (float)numberOfSteps : 1.0f; float f = numberOfSteps ? currentStep / (float)numberOfSteps : 1.0f;
Update( f * 0.5f ); Update( f * 0.5f );
} }
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Progress callback for post-processing steps /** @brief Progress callback for post-processing steps
* @param numberOfSteps The number of total post-processing * @param numberOfSteps The number of total post-processing
* steps * steps
* @param currentStep The index of the current post-processing * @param currentStep The index of the current post-processing
* step that will run, or equal to numberOfSteps if all of * step that will run, or equal to numberOfSteps if all of
* them has finished. This number is always strictly monotone * them has finished. This number is always strictly monotone
* increasing, although not necessarily linearly. * increasing, although not necessarily linearly.
* */ * */
virtual void UpdatePostProcess(int currentStep /*= 0*/, int numberOfSteps /*= 0*/) { virtual void UpdatePostProcess(int currentStep /*= 0*/, int numberOfSteps /*= 0*/) {
float f = numberOfSteps ? currentStep / (float)numberOfSteps : 1.0f; float f = numberOfSteps ? currentStep / (float)numberOfSteps : 1.0f;
Update( f * 0.5f + 0.5f ); Update( f * 0.5f + 0.5f );
} }
}; // !class ProgressHandler }; // !class ProgressHandler
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
} // Namespace Assimp } // Namespace Assimp
#endif #endif

28
include/assimp/ai_assert.h
View File

@ -1,14 +1,14 @@
/** @file ai_assert.h /** @file ai_assert.h
*/ */
#ifndef AI_DEBUG_H_INC #ifndef AI_DEBUG_H_INC
#define AI_DEBUG_H_INC #define AI_DEBUG_H_INC
#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)
#else #else
# define ai_assert(expression) # define ai_assert(expression)
#endif #endif
#endif #endif

968
include/assimp/anim.h
View File

@ -1,484 +1,484 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file anim.h /** @file anim.h
* @brief Defines the data structures in which the imported animations * @brief Defines the data structures in which the imported animations
* are returned. * are returned.
*/ */
#ifndef AI_ANIM_H_INC #ifndef AI_ANIM_H_INC
#define AI_ANIM_H_INC #define AI_ANIM_H_INC
#include "types.h" #include "types.h"
#include "quaternion.h" #include "quaternion.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** A time-value pair specifying a certain 3D vector for the given time. */ /** A time-value pair specifying a certain 3D vector for the given time. */
struct aiVectorKey struct aiVectorKey
{ {
/** The time of this key */ /** The time of this key */
double mTime; double mTime;
/** The value of this key */ /** The value of this key */
C_STRUCT aiVector3D mValue; C_STRUCT aiVector3D mValue;
#ifdef __cplusplus #ifdef __cplusplus
//! Default constructor //! Default constructor
aiVectorKey(){} aiVectorKey(){}
//! Construction from a given time and key value //! Construction from a given time and key value
aiVectorKey(double time, const aiVector3D& value) aiVectorKey(double time, const aiVector3D& value)
: mTime (time) : mTime (time)
, mValue (value) , mValue (value)
{} {}
typedef aiVector3D elem_type; typedef aiVector3D elem_type;
// Comparison operators. For use with std::find(); // Comparison operators. For use with std::find();
bool operator == (const aiVectorKey& o) const { bool operator == (const aiVectorKey& o) const {
return o.mValue == this->mValue; return o.mValue == this->mValue;
} }
bool operator != (const aiVectorKey& o) const { bool operator != (const aiVectorKey& o) const {
return o.mValue != this->mValue; return o.mValue != this->mValue;
} }
// Relational operators. For use with std::sort(); // Relational operators. For use with std::sort();
bool operator < (const aiVectorKey& o) const { bool operator < (const aiVectorKey& o) const {
return mTime < o.mTime; return mTime < o.mTime;
} }
bool operator > (const aiVectorKey& o) const { bool operator > (const aiVectorKey& o) const {
return mTime > o.mTime; return mTime > o.mTime;
} }
#endif #endif
}; };
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** A time-value pair specifying a rotation for the given time. /** A time-value pair specifying a rotation for the given time.
* Rotations are expressed with quaternions. */ * Rotations are expressed with quaternions. */
struct aiQuatKey struct aiQuatKey
{ {
/** The time of this key */ /** The time of this key */
double mTime; double mTime;
/** The value of this key */ /** The value of this key */
C_STRUCT aiQuaternion mValue; C_STRUCT aiQuaternion mValue;
#ifdef __cplusplus #ifdef __cplusplus
aiQuatKey(){ aiQuatKey(){
} }
/** Construction from a given time and key value */ /** Construction from a given time and key value */
aiQuatKey(double time, const aiQuaternion& value) aiQuatKey(double time, const aiQuaternion& value)
: mTime (time) : mTime (time)
, mValue (value) , mValue (value)
{} {}
typedef aiQuaternion elem_type; typedef aiQuaternion elem_type;
// Comparison operators. For use with std::find(); // Comparison operators. For use with std::find();
bool operator == (const aiQuatKey& o) const { bool operator == (const aiQuatKey& o) const {
return o.mValue == this->mValue; return o.mValue == this->mValue;
} }
bool operator != (const aiQuatKey& o) const { bool operator != (const aiQuatKey& o) const {
return o.mValue != this->mValue; return o.mValue != this->mValue;
} }
// Relational operators. For use with std::sort(); // Relational operators. For use with std::sort();
bool operator < (const aiQuatKey& o) const { bool operator < (const aiQuatKey& o) const {
return mTime < o.mTime; return mTime < o.mTime;
} }
bool operator > (const aiQuatKey& o) const { bool operator > (const aiQuatKey& o) const {
return mTime > o.mTime; return mTime > o.mTime;
} }
#endif #endif
}; };
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Binds a anim mesh to a specific point in time. */ /** Binds a anim mesh to a specific point in time. */
struct aiMeshKey struct aiMeshKey
{ {
/** The time of this key */ /** The time of this key */
double mTime; double mTime;
/** Index into the aiMesh::mAnimMeshes array of the /** Index into the aiMesh::mAnimMeshes array of the
* mesh coresponding to the #aiMeshAnim hosting this * mesh coresponding to the #aiMeshAnim hosting this
* key frame. The referenced anim mesh is evaluated * key frame. The referenced anim mesh is evaluated
* according to the rules defined in the docs for #aiAnimMesh.*/ * according to the rules defined in the docs for #aiAnimMesh.*/
unsigned int mValue; unsigned int mValue;
#ifdef __cplusplus #ifdef __cplusplus
aiMeshKey() { aiMeshKey() {
} }
/** Construction from a given time and key value */ /** Construction from a given time and key value */
aiMeshKey(double time, const unsigned int value) aiMeshKey(double time, const unsigned int value)
: mTime (time) : mTime (time)
, mValue (value) , mValue (value)
{} {}
typedef unsigned int elem_type; typedef unsigned int elem_type;
// Comparison operators. For use with std::find(); // Comparison operators. For use with std::find();
bool operator == (const aiMeshKey& o) const { bool operator == (const aiMeshKey& o) const {
return o.mValue == this->mValue; return o.mValue == this->mValue;
} }
bool operator != (const aiMeshKey& o) const { bool operator != (const aiMeshKey& o) const {
return o.mValue != this->mValue; return o.mValue != this->mValue;
} }
// Relational operators. For use with std::sort(); // Relational operators. For use with std::sort();
bool operator < (const aiMeshKey& o) const { bool operator < (const aiMeshKey& o) const {
return mTime < o.mTime; return mTime < o.mTime;
} }
bool operator > (const aiMeshKey& o) const { bool operator > (const aiMeshKey& o) const {
return mTime > o.mTime; return mTime > o.mTime;
} }
#endif #endif
}; };
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Defines how an animation channel behaves outside the defined time /** Defines how an animation channel behaves outside the defined time
* range. This corresponds to aiNodeAnim::mPreState and * range. This corresponds to aiNodeAnim::mPreState and
* aiNodeAnim::mPostState.*/ * aiNodeAnim::mPostState.*/
enum aiAnimBehaviour enum aiAnimBehaviour
{ {
/** The value from the default node transformation is taken*/ /** The value from the default node transformation is taken*/
aiAnimBehaviour_DEFAULT = 0x0, aiAnimBehaviour_DEFAULT = 0x0,
/** The nearest key value is used without interpolation */ /** The nearest key value is used without interpolation */
aiAnimBehaviour_CONSTANT = 0x1, aiAnimBehaviour_CONSTANT = 0x1,
/** The value of the nearest two keys is linearly /** The value of the nearest two keys is linearly
* extrapolated for the current time value.*/ * extrapolated for the current time value.*/
aiAnimBehaviour_LINEAR = 0x2, aiAnimBehaviour_LINEAR = 0x2,
/** The animation is repeated. /** The animation is repeated.
* *
* If the animation key go from n to m and the current * If the animation key go from n to m and the current
* time is t, use the value at (t-n) % (|m-n|).*/ * time is t, use the value at (t-n) % (|m-n|).*/
aiAnimBehaviour_REPEAT = 0x3, aiAnimBehaviour_REPEAT = 0x3,
/** This value is not used, it is just here to force the /** This value is not used, it is just here to force the
* the compiler to map this enum to a 32 Bit integer */ * the compiler to map this enum to a 32 Bit integer */
#ifndef SWIG #ifndef SWIG
_aiAnimBehaviour_Force32Bit = INT_MAX _aiAnimBehaviour_Force32Bit = INT_MAX
#endif #endif
}; };
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Describes the animation of a single node. The name specifies the /** Describes the animation of a single node. The name specifies the
* bone/node which is affected by this animation channel. The keyframes * bone/node which is affected by this animation channel. The keyframes
* are given in three separate series of values, one each for position, * are given in three separate series of values, one each for position,
* rotation and scaling. The transformation matrix computed from these * rotation and scaling. The transformation matrix computed from these
* values replaces the node's original transformation matrix at a * values replaces the node's original transformation matrix at a
* specific time. * specific time.
* This means all keys are absolute and not relative to the bone default pose. * This means all keys are absolute and not relative to the bone default pose.
* The order in which the transformations are applied is * The order in which the transformations are applied is
* - as usual - scaling, rotation, translation. * - as usual - scaling, rotation, translation.
* *
* @note All keys are returned in their correct, chronological order. * @note All keys are returned in their correct, chronological order.
* Duplicate keys don't pass the validation step. Most likely there * Duplicate keys don't pass the validation step. Most likely there
* will be no negative time values, but they are not forbidden also ( so * will be no negative time values, but they are not forbidden also ( so
* implementations need to cope with them! ) */ * implementations need to cope with them! ) */
struct aiNodeAnim struct aiNodeAnim
{ {
/** The name of the node affected by this animation. The node /** The name of the node affected by this animation. The node
* must exist and it must be unique.*/ * must exist and it must be unique.*/
C_STRUCT aiString mNodeName; C_STRUCT aiString mNodeName;
/** The number of position keys */ /** The number of position keys */
unsigned int mNumPositionKeys; unsigned int mNumPositionKeys;
/** The position keys of this animation channel. Positions are /** The position keys of this animation channel. Positions are
* specified as 3D vector. The array is mNumPositionKeys in size. * specified as 3D vector. The array is mNumPositionKeys in size.
* *
* If there are position keys, there will also be at least one * If there are position keys, there will also be at least one
* scaling and one rotation key.*/ * scaling and one rotation key.*/
C_STRUCT aiVectorKey* mPositionKeys; C_STRUCT aiVectorKey* mPositionKeys;
/** The number of rotation keys */ /** The number of rotation keys */
unsigned int mNumRotationKeys; unsigned int mNumRotationKeys;
/** The rotation keys of this animation channel. Rotations are /** The rotation keys of this animation channel. Rotations are
* given as quaternions, which are 4D vectors. The array is * given as quaternions, which are 4D vectors. The array is
* mNumRotationKeys in size. * mNumRotationKeys in size.
* *
* If there are rotation keys, there will also be at least one * If there are rotation keys, there will also be at least one
* scaling and one position key. */ * scaling and one position key. */
C_STRUCT aiQuatKey* mRotationKeys; C_STRUCT aiQuatKey* mRotationKeys;
/** The number of scaling keys */ /** The number of scaling keys */
unsigned int mNumScalingKeys; unsigned int mNumScalingKeys;
/** The scaling keys of this animation channel. Scalings are /** The scaling keys of this animation channel. Scalings are
* specified as 3D vector. The array is mNumScalingKeys in size. * specified as 3D vector. The array is mNumScalingKeys in size.
* *
* If there are scaling keys, there will also be at least one * If there are scaling keys, there will also be at least one
* position and one rotation key.*/ * position and one rotation key.*/
C_STRUCT aiVectorKey* mScalingKeys; C_STRUCT aiVectorKey* mScalingKeys;
/** Defines how the animation behaves before the first /** Defines how the animation behaves before the first
* key is encountered. * key is encountered.
* *
* The default value is aiAnimBehaviour_DEFAULT (the original * The default value is aiAnimBehaviour_DEFAULT (the original
* transformation matrix of the affected node is used).*/ * transformation matrix of the affected node is used).*/
C_ENUM aiAnimBehaviour mPreState; C_ENUM aiAnimBehaviour mPreState;
/** Defines how the animation behaves after the last /** Defines how the animation behaves after the last
* key was processed. * key was processed.
* *
* The default value is aiAnimBehaviour_DEFAULT (the original * The default value is aiAnimBehaviour_DEFAULT (the original
* transformation matrix of the affected node is taken).*/ * transformation matrix of the affected node is taken).*/
C_ENUM aiAnimBehaviour mPostState; C_ENUM aiAnimBehaviour mPostState;
#ifdef __cplusplus #ifdef __cplusplus
aiNodeAnim() aiNodeAnim()
{ {
mNumPositionKeys = 0; mPositionKeys = NULL; mNumPositionKeys = 0; mPositionKeys = NULL;
mNumRotationKeys = 0; mRotationKeys = NULL; mNumRotationKeys = 0; mRotationKeys = NULL;
mNumScalingKeys = 0; mScalingKeys = NULL; mNumScalingKeys = 0; mScalingKeys = NULL;
mPreState = mPostState = aiAnimBehaviour_DEFAULT; mPreState = mPostState = aiAnimBehaviour_DEFAULT;
} }
~aiNodeAnim() ~aiNodeAnim()
{ {
delete [] mPositionKeys; delete [] mPositionKeys;
delete [] mRotationKeys; delete [] mRotationKeys;
delete [] mScalingKeys; delete [] mScalingKeys;
} }
#endif // __cplusplus #endif // __cplusplus
}; };
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Describes vertex-based animations for a single mesh or a group of /** Describes vertex-based animations for a single mesh or a group of
* meshes. Meshes carry the animation data for each frame in their * meshes. Meshes carry the animation data for each frame in their
* aiMesh::mAnimMeshes array. The purpose of aiMeshAnim is to * aiMesh::mAnimMeshes array. The purpose of aiMeshAnim is to
* define keyframes linking each mesh attachment to a particular * define keyframes linking each mesh attachment to a particular
* point in time. */ * point in time. */
struct aiMeshAnim struct aiMeshAnim
{ {
/** Name of the mesh to be animated. An empty string is not allowed, /** Name of the mesh to be animated. An empty string is not allowed,
* animated meshes need to be named (not necessarily uniquely, * animated meshes need to be named (not necessarily uniquely,
* the name can basically serve as wildcard to select a group * the name can basically serve as wildcard to select a group
* of meshes with similar animation setup)*/ * of meshes with similar animation setup)*/
C_STRUCT aiString mName; C_STRUCT aiString mName;
/** Size of the #mKeys array. Must be 1, at least. */ /** Size of the #mKeys array. Must be 1, at least. */
unsigned int mNumKeys; unsigned int mNumKeys;
/** Key frames of the animation. May not be NULL. */ /** Key frames of the animation. May not be NULL. */
C_STRUCT aiMeshKey* mKeys; C_STRUCT aiMeshKey* mKeys;
#ifdef __cplusplus #ifdef __cplusplus
aiMeshAnim() aiMeshAnim()
: mNumKeys() : mNumKeys()
, mKeys() , mKeys()
{} {}
~aiMeshAnim() ~aiMeshAnim()
{ {
delete[] mKeys; delete[] mKeys;
} }
#endif #endif
}; };
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** An animation consists of keyframe data for a number of nodes. For /** An animation consists of keyframe data for a number of nodes. For
* each node affected by the animation a separate series of data is given.*/ * each node affected by the animation a separate series of data is given.*/
struct aiAnimation struct aiAnimation
{ {
/** The name of the animation. If the modeling package this data was /** The name of the animation. If the modeling package this data was
* exported from does support only a single animation channel, this * exported from does support only a single animation channel, this
* name is usually empty (length is zero). */ * name is usually empty (length is zero). */
C_STRUCT aiString mName; C_STRUCT aiString mName;
/** Duration of the animation in ticks. */ /** Duration of the animation in ticks. */
double mDuration; double mDuration;
/** Ticks per second. 0 if not specified in the imported file */ /** Ticks per second. 0 if not specified in the imported file */
double mTicksPerSecond; double mTicksPerSecond;
/** The number of bone animation channels. Each channel affects /** The number of bone animation channels. Each channel affects
* a single node. */ * a single node. */
unsigned int mNumChannels; unsigned int mNumChannels;
/** The node animation channels. Each channel affects a single node. /** The node animation channels. Each channel affects a single node.
* The array is mNumChannels in size. */ * The array is mNumChannels in size. */
C_STRUCT aiNodeAnim** mChannels; C_STRUCT aiNodeAnim** mChannels;
/** The number of mesh animation channels. Each channel affects /** The number of mesh animation channels. Each channel affects
* a single mesh and defines vertex-based animation. */ * a single mesh and defines vertex-based animation. */
unsigned int mNumMeshChannels; unsigned int mNumMeshChannels;
/** The mesh animation channels. Each channel affects a single mesh. /** The mesh animation channels. Each channel affects a single mesh.
* The array is mNumMeshChannels in size. */ * The array is mNumMeshChannels in size. */
C_STRUCT aiMeshAnim** mMeshChannels; C_STRUCT aiMeshAnim** mMeshChannels;
#ifdef __cplusplus #ifdef __cplusplus
aiAnimation() aiAnimation()
: mDuration(-1.) : mDuration(-1.)
, mTicksPerSecond() , mTicksPerSecond()
, mNumChannels() , mNumChannels()
, mChannels() , mChannels()
, mNumMeshChannels() , mNumMeshChannels()
, mMeshChannels() , mMeshChannels()
{ {
} }
~aiAnimation() ~aiAnimation()
{ {
// DO NOT REMOVE THIS ADDITIONAL CHECK // DO NOT REMOVE THIS ADDITIONAL CHECK
if (mNumChannels && mChannels) { if (mNumChannels && mChannels) {
for( unsigned int a = 0; a < mNumChannels; a++) { for( unsigned int a = 0; a < mNumChannels; a++) {
delete mChannels[a]; delete mChannels[a];
} }
delete [] mChannels; delete [] mChannels;
} }
if (mNumMeshChannels && mMeshChannels) { if (mNumMeshChannels && mMeshChannels) {
for( unsigned int a = 0; a < mNumMeshChannels; a++) { for( unsigned int a = 0; a < mNumMeshChannels; a++) {
delete mMeshChannels[a]; delete mMeshChannels[a];
} }
delete [] mMeshChannels; delete [] mMeshChannels;
} }
} }
#endif // __cplusplus #endif // __cplusplus
}; };
#ifdef __cplusplus #ifdef __cplusplus
} }
// some C++ utilities for inter- and extrapolation // some C++ utilities for inter- and extrapolation
namespace Assimp { namespace Assimp {
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief CPP-API: Utility class to simplify interpolations of various data types. /** @brief CPP-API: Utility class to simplify interpolations of various data types.
* *
* The type of interpolation is choosen automatically depending on the * The type of interpolation is choosen automatically depending on the
* types of the arguments. */ * types of the arguments. */
template <typename T> template <typename T>
struct Interpolator struct Interpolator
{ {
// ------------------------------------------------------------------ // ------------------------------------------------------------------
/** @brief Get the result of the interpolation between a,b. /** @brief Get the result of the interpolation between a,b.
* *
* The interpolation algorithm depends on the type of the operands. * The interpolation algorithm depends on the type of the operands.
* aiQuaternion's and aiQuatKey's SLERP, the rest does a simple * aiQuaternion's and aiQuatKey's SLERP, the rest does a simple
* linear interpolation. */ * linear interpolation. */
void operator () (T& out,const T& a, const T& b, float d) const { void operator () (T& out,const T& a, const T& b, float d) const {
out = a + (b-a)*d; out = a + (b-a)*d;
} }
}; // ! Interpolator <T> }; // ! Interpolator <T>
//! @cond Never //! @cond Never
template <> template <>
struct Interpolator <aiQuaternion> { struct Interpolator <aiQuaternion> {
void operator () (aiQuaternion& out,const aiQuaternion& a, void operator () (aiQuaternion& out,const aiQuaternion& a,
const aiQuaternion& b, float d) const const aiQuaternion& b, float d) const
{ {
aiQuaternion::Interpolate(out,a,b,d); aiQuaternion::Interpolate(out,a,b,d);
} }
}; // ! Interpolator <aiQuaternion> }; // ! Interpolator <aiQuaternion>
template <> template <>
struct Interpolator <unsigned int> { struct Interpolator <unsigned int> {
void operator () (unsigned int& out,unsigned int a, void operator () (unsigned int& out,unsigned int a,
unsigned int b, float d) const unsigned int b, float d) const
{ {
out = d>0.5f ? b : a; out = d>0.5f ? b : a;
} }
}; // ! Interpolator <aiQuaternion> }; // ! Interpolator <aiQuaternion>
template <> template <>
struct Interpolator <aiVectorKey> { struct Interpolator <aiVectorKey> {
void operator () (aiVector3D& out,const aiVectorKey& a, void operator () (aiVector3D& out,const aiVectorKey& a,
const aiVectorKey& b, float d) const const aiVectorKey& b, float d) const
{ {
Interpolator<aiVector3D> ipl; Interpolator<aiVector3D> ipl;
ipl(out,a.mValue,b.mValue,d); ipl(out,a.mValue,b.mValue,d);
} }
}; // ! Interpolator <aiVectorKey> }; // ! Interpolator <aiVectorKey>
template <> template <>
struct Interpolator <aiQuatKey> { struct Interpolator <aiQuatKey> {
void operator () (aiQuaternion& out, const aiQuatKey& a, void operator () (aiQuaternion& out, const aiQuatKey& a,
const aiQuatKey& b, float d) const const aiQuatKey& b, float d) const
{ {
Interpolator<aiQuaternion> ipl; Interpolator<aiQuaternion> ipl;
ipl(out,a.mValue,b.mValue,d); ipl(out,a.mValue,b.mValue,d);
} }
}; // ! Interpolator <aiQuatKey> }; // ! Interpolator <aiQuatKey>
template <> template <>
struct Interpolator <aiMeshKey> { struct Interpolator <aiMeshKey> {
void operator () (unsigned int& out, const aiMeshKey& a, void operator () (unsigned int& out, const aiMeshKey& a,
const aiMeshKey& b, float d) const const aiMeshKey& b, float d) const
{ {
Interpolator<unsigned int> ipl; Interpolator<unsigned int> ipl;
ipl(out,a.mValue,b.mValue,d); ipl(out,a.mValue,b.mValue,d);
} }
}; // ! Interpolator <aiQuatKey> }; // ! Interpolator <aiQuatKey>
//! @endcond //! @endcond
} // ! end namespace Assimp } // ! end namespace Assimp
#endif // __cplusplus #endif // __cplusplus
#endif // AI_ANIM_H_INC #endif // AI_ANIM_H_INC

446
include/assimp/camera.h
View File

@ -1,223 +1,223 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file camera.h /** @file camera.h
* @brief Defines the aiCamera data structure * @brief Defines the aiCamera data structure
*/ */
#ifndef AI_CAMERA_H_INC #ifndef AI_CAMERA_H_INC
#define AI_CAMERA_H_INC #define AI_CAMERA_H_INC
#include "types.h" #include "types.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Helper structure to describe a virtual camera. /** Helper structure to describe a virtual camera.
* *
* Cameras have a representation in the node graph and can be animated. * Cameras have a representation in the node graph and can be animated.
* An important aspect is that the camera itself is also part of the * An important aspect is that the camera itself is also part of the
* scenegraph. This means, any values such as the look-at vector are not * scenegraph. This means, any values such as the look-at vector are not
* *absolute*, they're <b>relative</b> to the coordinate system defined * *absolute*, they're <b>relative</b> to the coordinate system defined
* by the node which corresponds to the camera. This allows for camera * by the node which corresponds to the camera. This allows for camera
* animations. For static cameras parameters like the 'look-at' or 'up' vectors * animations. For static cameras parameters like the 'look-at' or 'up' vectors
* are usually specified directly in aiCamera, but beware, they could also * are usually specified directly in aiCamera, but beware, they could also
* be encoded in the node transformation. The following (pseudo)code sample * be encoded in the node transformation. The following (pseudo)code sample
* shows how to do it: <br><br> * shows how to do it: <br><br>
* @code * @code
* // Get the camera matrix for a camera at a specific time * // Get the camera matrix for a camera at a specific time
* // if the node hierarchy for the camera does not contain * // if the node hierarchy for the camera does not contain
* // at least one animated node this is a static computation * // at least one animated node this is a static computation
* get-camera-matrix (node sceneRoot, camera cam) : matrix * get-camera-matrix (node sceneRoot, camera cam) : matrix
* { * {
* node cnd = find-node-for-camera(cam) * node cnd = find-node-for-camera(cam)
* matrix cmt = identity() * matrix cmt = identity()
* *
* // as usual - get the absolute camera transformation for this frame * // as usual - get the absolute camera transformation for this frame
* for each node nd in hierarchy from sceneRoot to cnd * for each node nd in hierarchy from sceneRoot to cnd
* matrix cur * matrix cur
* if (is-animated(nd)) * if (is-animated(nd))
* cur = eval-animation(nd) * cur = eval-animation(nd)
* else cur = nd->mTransformation; * else cur = nd->mTransformation;
* cmt = mult-matrices( cmt, cur ) * cmt = mult-matrices( cmt, cur )
* end for * end for
* *
* // now multiply with the camera's own local transform * // now multiply with the camera's own local transform
* cam = mult-matrices (cam, get-camera-matrix(cmt) ) * cam = mult-matrices (cam, get-camera-matrix(cmt) )
* } * }
* @endcode * @endcode
* *
* @note some file formats (such as 3DS, ASE) export a "target point" - * @note some file formats (such as 3DS, ASE) export a "target point" -
* the point the camera is looking at (it can even be animated). Assimp * the point the camera is looking at (it can even be animated). Assimp
* writes the target point as a subnode of the camera's main node, * writes the target point as a subnode of the camera's main node,
* called "<camName>.Target". However this is just additional information * called "<camName>.Target". However this is just additional information
* then the transformation tracks of the camera main node make the * then the transformation tracks of the camera main node make the
* camera already look in the right direction. * camera already look in the right direction.
* *
*/ */
struct aiCamera struct aiCamera
{ {
/** The name of the camera. /** The name of the camera.
* *
* There must be a node in the scenegraph with the same name. * There must be a node in the scenegraph with the same name.
* This node specifies the position of the camera in the scene * This node specifies the position of the camera in the scene
* hierarchy and can be animated. * hierarchy and can be animated.
*/ */
C_STRUCT aiString mName; C_STRUCT aiString mName;
/** Position of the camera relative to the coordinate space /** Position of the camera relative to the coordinate space
* defined by the corresponding node. * defined by the corresponding node.
* *
* The default value is 0|0|0. * The default value is 0|0|0.
*/ */
C_STRUCT aiVector3D mPosition; C_STRUCT aiVector3D mPosition;
/** 'Up' - vector of the camera coordinate system relative to /** 'Up' - vector of the camera coordinate system relative to
* the coordinate space defined by the corresponding node. * the coordinate space defined by the corresponding node.
* *
* The 'right' vector of the camera coordinate system is * The 'right' vector of the camera coordinate system is
* the cross product of the up and lookAt vectors. * the cross product of the up and lookAt vectors.
* The default value is 0|1|0. The vector * The default value is 0|1|0. The vector
* may be normalized, but it needn't. * may be normalized, but it needn't.
*/ */
C_STRUCT aiVector3D mUp; C_STRUCT aiVector3D mUp;
/** 'LookAt' - vector of the camera coordinate system relative to /** 'LookAt' - vector of the camera coordinate system relative to
* the coordinate space defined by the corresponding node. * the coordinate space defined by the corresponding node.
* *
* This is the viewing direction of the user. * This is the viewing direction of the user.
* The default value is 0|0|1. The vector * The default value is 0|0|1. The vector
* may be normalized, but it needn't. * may be normalized, but it needn't.
*/ */
C_STRUCT aiVector3D mLookAt; C_STRUCT aiVector3D mLookAt;
/** Half horizontal field of view angle, in radians. /** Half horizontal field of view angle, in radians.
* *
* The field of view angle is the angle between the center * The field of view angle is the angle between the center
* line of the screen and the left or right border. * line of the screen and the left or right border.
* The default value is 1/4PI. * The default value is 1/4PI.
*/ */
float mHorizontalFOV; float mHorizontalFOV;
/** Distance of the near clipping plane from the camera. /** Distance of the near clipping plane from the camera.
* *
* The value may not be 0.f (for arithmetic reasons to prevent * The value may not be 0.f (for arithmetic reasons to prevent
* a division through zero). The default value is 0.1f. * a division through zero). The default value is 0.1f.
*/ */
float mClipPlaneNear; float mClipPlaneNear;
/** Distance of the far clipping plane from the camera. /** Distance of the far clipping plane from the camera.
* *
* The far clipping plane must, of course, be further away than the * The far clipping plane must, of course, be further away than the
* near clipping plane. The default value is 1000.f. The ratio * near clipping plane. The default value is 1000.f. The ratio
* between the near and the far plane should not be too * between the near and the far plane should not be too
* large (between 1000-10000 should be ok) to avoid floating-point * large (between 1000-10000 should be ok) to avoid floating-point
* inaccuracies which could lead to z-fighting. * inaccuracies which could lead to z-fighting.
*/ */
float mClipPlaneFar; float mClipPlaneFar;
/** Screen aspect ratio. /** Screen aspect ratio.
* *
* This is the ration between the width and the height of the * This is the ration between the width and the height of the
* screen. Typical values are 4/3, 1/2 or 1/1. This value is * screen. Typical values are 4/3, 1/2 or 1/1. This value is
* 0 if the aspect ratio is not defined in the source file. * 0 if the aspect ratio is not defined in the source file.
* 0 is also the default value. * 0 is also the default value.
*/ */
float mAspect; float mAspect;
#ifdef __cplusplus #ifdef __cplusplus
aiCamera() aiCamera()
: mUp (0.f,1.f,0.f) : mUp (0.f,1.f,0.f)
, mLookAt (0.f,0.f,1.f) , mLookAt (0.f,0.f,1.f)
, mHorizontalFOV (0.25f * (float)AI_MATH_PI) , mHorizontalFOV (0.25f * (float)AI_MATH_PI)
, mClipPlaneNear (0.1f) , mClipPlaneNear (0.1f)
, mClipPlaneFar (1000.f) , mClipPlaneFar (1000.f)
, mAspect (0.f) , mAspect (0.f)
{} {}
/** @brief Get a *right-handed* camera matrix from me /** @brief Get a *right-handed* camera matrix from me
* @param out Camera matrix to be filled * @param out Camera matrix to be filled
*/ */
void GetCameraMatrix (aiMatrix4x4& out) const void GetCameraMatrix (aiMatrix4x4& out) const
{ {
/** todo: test ... should work, but i'm not absolutely sure */ /** todo: test ... should work, but i'm not absolutely sure */
/** We don't know whether these vectors are already normalized ...*/ /** We don't know whether these vectors are already normalized ...*/
aiVector3D zaxis = mLookAt; zaxis.Normalize(); aiVector3D zaxis = mLookAt; zaxis.Normalize();
aiVector3D yaxis = mUp; yaxis.Normalize(); aiVector3D yaxis = mUp; yaxis.Normalize();
aiVector3D xaxis = mUp^mLookAt; xaxis.Normalize(); aiVector3D xaxis = mUp^mLookAt; xaxis.Normalize();
out.a4 = -(xaxis * mPosition); out.a4 = -(xaxis * mPosition);
out.b4 = -(yaxis * mPosition); out.b4 = -(yaxis * mPosition);
out.c4 = -(zaxis * mPosition); out.c4 = -(zaxis * mPosition);
out.a1 = xaxis.x; out.a1 = xaxis.x;
out.a2 = xaxis.y; out.a2 = xaxis.y;
out.a3 = xaxis.z; out.a3 = xaxis.z;
out.b1 = yaxis.x; out.b1 = yaxis.x;
out.b2 = yaxis.y; out.b2 = yaxis.y;
out.b3 = yaxis.z; out.b3 = yaxis.z;
out.c1 = zaxis.x; out.c1 = zaxis.x;
out.c2 = zaxis.y; out.c2 = zaxis.y;
out.c3 = zaxis.z; out.c3 = zaxis.z;
out.d1 = out.d2 = out.d3 = 0.f; out.d1 = out.d2 = out.d3 = 0.f;
out.d4 = 1.f; out.d4 = 1.f;
} }
#endif #endif
}; };
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif // AI_CAMERA_H_INC #endif // AI_CAMERA_H_INC

270
include/assimp/cfileio.h
View File

@ -1,135 +1,135 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file cfileio.h /** @file cfileio.h
* @brief Defines generic C routines to access memory-mapped files * @brief Defines generic C routines to access memory-mapped files
*/ */
#ifndef AI_FILEIO_H_INC #ifndef AI_FILEIO_H_INC
#define AI_FILEIO_H_INC #define AI_FILEIO_H_INC
#include "types.h" #include "types.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
struct aiFileIO; struct aiFileIO;
struct aiFile; struct aiFile;
// aiFile callbacks // aiFile callbacks
typedef size_t (*aiFileWriteProc) (C_STRUCT aiFile*, const char*, size_t, size_t); typedef size_t (*aiFileWriteProc) (C_STRUCT aiFile*, const char*, size_t, size_t);
typedef size_t (*aiFileReadProc) (C_STRUCT aiFile*, char*, size_t,size_t); typedef size_t (*aiFileReadProc) (C_STRUCT aiFile*, char*, size_t,size_t);
typedef size_t (*aiFileTellProc) (C_STRUCT aiFile*); typedef size_t (*aiFileTellProc) (C_STRUCT aiFile*);
typedef void (*aiFileFlushProc) (C_STRUCT aiFile*); typedef void (*aiFileFlushProc) (C_STRUCT aiFile*);
typedef aiReturn (*aiFileSeek)(C_STRUCT aiFile*, size_t, aiOrigin); typedef aiReturn (*aiFileSeek)(C_STRUCT aiFile*, size_t, aiOrigin);
// aiFileIO callbacks // aiFileIO callbacks
typedef aiFile* (*aiFileOpenProc) (C_STRUCT aiFileIO*, const char*, const char*); typedef aiFile* (*aiFileOpenProc) (C_STRUCT aiFileIO*, const char*, const char*);
typedef void (*aiFileCloseProc) (C_STRUCT aiFileIO*, C_STRUCT aiFile*); typedef void (*aiFileCloseProc) (C_STRUCT aiFileIO*, C_STRUCT aiFile*);
// Represents user-defined data // Represents user-defined data
typedef char* aiUserData; typedef char* aiUserData;
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
/** @brief C-API: File system callbacks /** @brief C-API: File system callbacks
* *
* Provided are functions to open and close files. Supply a custom structure to * Provided are functions to open and close files. Supply a custom structure to
* the import function. If you don't, a default implementation is used. Use custom * the import function. If you don't, a default implementation is used. Use custom
* file systems to enable reading from other sources, such as ZIPs * file systems to enable reading from other sources, such as ZIPs
* or memory locations. */ * or memory locations. */
struct aiFileIO struct aiFileIO
{ {
/** Function used to open a new file /** Function used to open a new file
*/ */
aiFileOpenProc OpenProc; aiFileOpenProc OpenProc;
/** Function used to close an existing file /** Function used to close an existing file
*/ */
aiFileCloseProc CloseProc; aiFileCloseProc CloseProc;
/** User-defined, opaque data */ /** User-defined, opaque data */
aiUserData UserData; aiUserData UserData;
}; };
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
/** @brief C-API: File callbacks /** @brief C-API: File callbacks
* *
* Actually, it's a data structure to wrap a set of fXXXX (e.g fopen) * Actually, it's a data structure to wrap a set of fXXXX (e.g fopen)
* replacement functions. * replacement functions.
* *
* The default implementation of the functions utilizes the fXXX functions from * The default implementation of the functions utilizes the fXXX functions from
* the CRT. However, you can supply a custom implementation to Assimp by * the CRT. However, you can supply a custom implementation to Assimp by
* delivering a custom aiFileIO. Use this to enable reading from other sources, * delivering a custom aiFileIO. Use this to enable reading from other sources,
* such as ZIP archives or memory locations. */ * such as ZIP archives or memory locations. */
struct aiFile struct aiFile
{ {
/** Callback to read from a file */ /** Callback to read from a file */
aiFileReadProc ReadProc; aiFileReadProc ReadProc;
/** Callback to write to a file */ /** Callback to write to a file */
aiFileWriteProc WriteProc; aiFileWriteProc WriteProc;
/** Callback to retrieve the current position of /** Callback to retrieve the current position of
* the file cursor (ftell()) * the file cursor (ftell())
*/ */
aiFileTellProc TellProc; aiFileTellProc TellProc;
/** Callback to retrieve the size of the file, /** Callback to retrieve the size of the file,
* in bytes * in bytes
*/ */
aiFileTellProc FileSizeProc; aiFileTellProc FileSizeProc;
/** Callback to set the current position /** Callback to set the current position
* of the file cursor (fseek()) * of the file cursor (fseek())
*/ */
aiFileSeek SeekProc; aiFileSeek SeekProc;
/** Callback to flush the file contents /** Callback to flush the file contents
*/ */
aiFileFlushProc FlushProc; aiFileFlushProc FlushProc;
/** User-defined, opaque data /** User-defined, opaque data
*/ */
aiUserData UserData; aiUserData UserData;
}; };
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif // AI_FILEIO_H_INC #endif // AI_FILEIO_H_INC

1122
include/assimp/cimport.h
View File

File diff suppressed because it is too large Load Diff

208
include/assimp/color4.h
View File

@ -1,104 +1,104 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file color4.h /** @file color4.h
* @brief RGBA color structure, including operators when compiling in C++ * @brief RGBA color structure, including operators when compiling in C++
*/ */
#ifndef AI_COLOR4D_H_INC #ifndef AI_COLOR4D_H_INC
#define AI_COLOR4D_H_INC #define AI_COLOR4D_H_INC
#include "./Compiler/pushpack1.h" #include "./Compiler/pushpack1.h"
#ifdef __cplusplus #ifdef __cplusplus
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
/** Represents a color in Red-Green-Blue space including an /** Represents a color in Red-Green-Blue space including an
* 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 () : r(), g(), b(), a() {} aiColor4t () : r(), g(), b(), a() {}
aiColor4t (TReal _r, TReal _g, TReal _b, TReal _a) aiColor4t (TReal _r, TReal _g, TReal _b, TReal _a)
: r(_r), g(_g), b(_b), a(_a) {} : r(_r), g(_g), b(_b), a(_a) {}
aiColor4t (TReal _r) : r(_r), g(_r), b(_r), a(_r) {} aiColor4t (TReal _r) : r(_r), g(_r), b(_r), a(_r) {}
aiColor4t (const aiColor4t& o) aiColor4t (const aiColor4t& o)
: r(o.r), g(o.g), b(o.b), a(o.a) {} : r(o.r), g(o.g), b(o.b), a(o.a) {}
public: 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: 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;
bool operator < (const aiColor4t& other) const; bool operator < (const aiColor4t& other) const;
// color tuple access, rgba order // color tuple access, rgba order
inline TReal operator[](unsigned int i) const; inline TReal operator[](unsigned int i) const;
inline TReal& operator[](unsigned int i); inline TReal& operator[](unsigned int i);
/** 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: 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;
} PACK_STRUCT; // !struct aiColor4D } PACK_STRUCT; // !struct aiColor4D
typedef aiColor4t<float> aiColor4D; typedef aiColor4t<float> aiColor4D;
#else #else
struct aiColor4D { struct aiColor4D {
float r, g, b, a; float r, g, b, a;
} PACK_STRUCT; } PACK_STRUCT;
#endif // __cplusplus #endif // __cplusplus
#include "./Compiler/poppack1.h" #include "./Compiler/poppack1.h"
#endif // AI_COLOR4D_H_INC #endif // AI_COLOR4D_H_INC

364
include/assimp/color4.inl
View File

@ -1,182 +1,182 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file color4.inl /** @file color4.inl
* @brief Inline implementation of aiColor4t<TReal> operators * @brief Inline implementation of aiColor4t<TReal> operators
*/ */
#ifndef AI_COLOR4D_INL_INC #ifndef AI_COLOR4D_INL_INC
#define AI_COLOR4D_INL_INC #define AI_COLOR4D_INL_INC
#ifdef __cplusplus #ifdef __cplusplus
#include "color4.h" #include "color4.h"
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator += (const aiColor4t<TReal>& o) { AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator += (const aiColor4t<TReal>& o) {
r += o.r; g += o.g; b += o.b; a += o.a; 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 const aiColor4t<TReal>& aiColor4t<TReal>::operator -= (const aiColor4t<TReal>& o) {
r -= o.r; g -= o.g; b -= o.b; a -= o.a; 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 const aiColor4t<TReal>& aiColor4t<TReal>::operator *= (TReal f) {
r *= f; g *= f; b *= f; a *= 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 const aiColor4t<TReal>& aiColor4t<TReal>::operator /= (TReal f) {
r /= f; g /= f; b /= f; a /= 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 {
return *(&r + i); return *(&r + i);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
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) {
return *(&r + i); return *(&r + 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 || (
g == other.g && ( g == other.g && (
b < other.b || ( b < other.b || (
b == other.b && ( b == other.b && (
a < other.a a < other.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 - (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);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
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 { 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;
} }
#endif // __cplusplus #endif // __cplusplus
#endif // AI_VECTOR3D_INL_INC #endif // AI_VECTOR3D_INL_INC

1816
include/assimp/config.h
View File

File diff suppressed because it is too large Load Diff

558
include/assimp/defs.h
View File

@ -1,279 +1,279 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file defs.h /** @file defs.h
* @brief Assimp build configuration setup. See the notes in the comment * @brief Assimp build configuration setup. See the notes in the comment
* blocks to find out how to customize _your_ Assimp build. * blocks to find out how to customize _your_ Assimp build.
*/ */
#ifndef INCLUDED_AI_DEFINES_H #ifndef INCLUDED_AI_DEFINES_H
#define INCLUDED_AI_DEFINES_H #define INCLUDED_AI_DEFINES_H
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Define ASSIMP_BUILD_NO_XX_IMPORTER to disable a specific /* Define ASSIMP_BUILD_NO_XX_IMPORTER to disable a specific
* file format loader. The loader is be excluded from the * file format loader. The loader is be excluded from the
* build in this case. 'XX' stands for the most common file * build in this case. 'XX' stands for the most common file
* extension of the file format. E.g.: * extension of the file format. E.g.:
* ASSIMP_BUILD_NO_X_IMPORTER disables the X loader. * ASSIMP_BUILD_NO_X_IMPORTER disables the X loader.
* *
* If you're unsure about that, take a look at the implementation of the * If you're unsure about that, take a look at the implementation of the
* import plugin you wish to disable. You'll find the right define in the * import plugin you wish to disable. You'll find the right define in the
* first lines of the corresponding unit. * first lines of the corresponding unit.
* *
* Other (mixed) configuration switches are listed here: * Other (mixed) configuration switches are listed here:
* ASSIMP_BUILD_NO_COMPRESSED_X * ASSIMP_BUILD_NO_COMPRESSED_X
* - Disable support for compressed X files (zip) * - Disable support for compressed X files (zip)
* ASSIMP_BUILD_NO_COMPRESSED_BLEND * ASSIMP_BUILD_NO_COMPRESSED_BLEND
* - Disable support for compressed Blender files (zip) * - Disable support for compressed Blender files (zip)
* ASSIMP_BUILD_NO_COMPRESSED_IFC * ASSIMP_BUILD_NO_COMPRESSED_IFC
* - Disable support for IFCZIP files (unzip) * - Disable support for IFCZIP files (unzip)
*/ */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
#ifndef ASSIMP_BUILD_NO_COMPRESSED_X #ifndef ASSIMP_BUILD_NO_COMPRESSED_X
# define ASSIMP_BUILD_NEED_Z_INFLATE # define ASSIMP_BUILD_NEED_Z_INFLATE
#endif #endif
#ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND #ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND
# define ASSIMP_BUILD_NEED_Z_INFLATE # define ASSIMP_BUILD_NEED_Z_INFLATE
#endif #endif
#ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC #ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
# define ASSIMP_BUILD_NEED_Z_INFLATE # define ASSIMP_BUILD_NEED_Z_INFLATE
# define ASSIMP_BUILD_NEED_UNZIP # define ASSIMP_BUILD_NEED_UNZIP
#endif #endif
#ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER #ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER
# define ASSIMP_BUILD_NEED_Z_INFLATE # define ASSIMP_BUILD_NEED_Z_INFLATE
# define ASSIMP_BUILD_NEED_UNZIP # define ASSIMP_BUILD_NEED_UNZIP
#endif #endif
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Define ASSIMP_BUILD_NO_XX_PROCESS to disable a specific /* Define ASSIMP_BUILD_NO_XX_PROCESS to disable a specific
* post processing step. This is the current list of process names ('XX'): * post processing step. This is the current list of process names ('XX'):
* CALCTANGENTS * CALCTANGENTS
* JOINVERTICES * JOINVERTICES
* TRIANGULATE * TRIANGULATE
* GENFACENORMALS * GENFACENORMALS
* GENVERTEXNORMALS * GENVERTEXNORMALS
* REMOVEVC * REMOVEVC
* SPLITLARGEMESHES * SPLITLARGEMESHES
* PRETRANSFORMVERTICES * PRETRANSFORMVERTICES
* LIMITBONEWEIGHTS * LIMITBONEWEIGHTS
* VALIDATEDS * VALIDATEDS
* IMPROVECACHELOCALITY * IMPROVECACHELOCALITY
* FIXINFACINGNORMALS * FIXINFACINGNORMALS
* REMOVE_REDUNDANTMATERIALS * REMOVE_REDUNDANTMATERIALS
* OPTIMIZEGRAPH * OPTIMIZEGRAPH
* SORTBYPTYPE * SORTBYPTYPE
* FINDINVALIDDATA * FINDINVALIDDATA
* TRANSFORMTEXCOORDS * TRANSFORMTEXCOORDS
* GENUVCOORDS * GENUVCOORDS
* ENTITYMESHBUILDER * ENTITYMESHBUILDER
* MAKELEFTHANDED * MAKELEFTHANDED
* FLIPUVS * FLIPUVS
* FLIPWINDINGORDER * FLIPWINDINGORDER
* OPTIMIZEMESHES * OPTIMIZEMESHES
* OPTIMIZEANIMS * OPTIMIZEANIMS
* OPTIMIZEGRAPH * OPTIMIZEGRAPH
* GENENTITYMESHES * GENENTITYMESHES
* FIXTEXTUREPATHS */ * FIXTEXTUREPATHS */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
#ifdef _MSC_VER #ifdef _MSC_VER
# undef ASSIMP_API # undef ASSIMP_API
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Define 'ASSIMP_BUILD_DLL_EXPORT' to build a DLL of the library */ /* Define 'ASSIMP_BUILD_DLL_EXPORT' to build a DLL of the library */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
# ifdef ASSIMP_BUILD_DLL_EXPORT # ifdef ASSIMP_BUILD_DLL_EXPORT
# define ASSIMP_API __declspec(dllexport) # define ASSIMP_API __declspec(dllexport)
# define ASSIMP_API_WINONLY __declspec(dllexport) # define ASSIMP_API_WINONLY __declspec(dllexport)
# pragma warning (disable : 4251) # pragma warning (disable : 4251)
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Define 'ASSIMP_DLL' before including Assimp to link to ASSIMP in /* Define 'ASSIMP_DLL' before including Assimp to link to ASSIMP in
* an external DLL under Windows. Default is static linkage. */ * an external DLL under Windows. Default is static linkage. */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
# elif (defined ASSIMP_DLL) # elif (defined ASSIMP_DLL)
# define ASSIMP_API __declspec(dllimport) # define ASSIMP_API __declspec(dllimport)
# define ASSIMP_API_WINONLY __declspec(dllimport) # define ASSIMP_API_WINONLY __declspec(dllimport)
# else # else
# define ASSIMP_API # define ASSIMP_API
# define ASSIMP_API_WINONLY # define ASSIMP_API_WINONLY
# endif # endif
/* Force the compiler to inline a function, if possible /* Force the compiler to inline a function, if possible
*/ */
# define AI_FORCE_INLINE __forceinline # define AI_FORCE_INLINE __forceinline
/* Tells the compiler that a function never returns. Used in code analysis /* Tells the compiler that a function never returns. Used in code analysis
* to skip dead paths (e.g. after an assertion evaluated to false). */ * to skip dead paths (e.g. after an assertion evaluated to false). */
# define AI_WONT_RETURN __declspec(noreturn) # define AI_WONT_RETURN __declspec(noreturn)
#elif defined(SWIG) #elif defined(SWIG)
/* Do nothing, the relevant defines are all in AssimpSwigPort.i */ /* Do nothing, the relevant defines are all in AssimpSwigPort.i */
#else #else
# define AI_WONT_RETURN # define AI_WONT_RETURN
# define ASSIMP_API __attribute__ ((visibility("default"))) # define ASSIMP_API __attribute__ ((visibility("default")))
# define ASSIMP_API_WINONLY # define ASSIMP_API_WINONLY
# define AI_FORCE_INLINE inline # define AI_FORCE_INLINE inline
#endif // (defined _MSC_VER) #endif // (defined _MSC_VER)
#ifdef __GNUC__ #ifdef __GNUC__
# define AI_WONT_RETURN_SUFFIX __attribute__((noreturn)) # define AI_WONT_RETURN_SUFFIX __attribute__((noreturn))
#else #else
# define AI_WONT_RETURN_SUFFIX # define AI_WONT_RETURN_SUFFIX
#endif // (defined __clang__) #endif // (defined __clang__)
#ifdef __cplusplus #ifdef __cplusplus
/* No explicit 'struct' and 'enum' tags for C++, this keeps showing up /* No explicit 'struct' and 'enum' tags for C++, this keeps showing up
* in doxydocs. * in doxydocs.
*/ */
# define C_STRUCT # define C_STRUCT
# define C_ENUM # define C_ENUM
#else #else
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* To build the documentation, make sure ASSIMP_DOXYGEN_BUILD /* To build the documentation, make sure ASSIMP_DOXYGEN_BUILD
* is defined by Doxygen's preprocessor. The corresponding * is defined by Doxygen's preprocessor. The corresponding
* entries in the DOXYFILE are: */ * entries in the DOXYFILE are: */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
#if 0 #if 0
ENABLE_PREPROCESSING = YES ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = YES MACRO_EXPANSION = YES
EXPAND_ONLY_PREDEF = YES EXPAND_ONLY_PREDEF = YES
SEARCH_INCLUDES = YES SEARCH_INCLUDES = YES
INCLUDE_PATH = INCLUDE_PATH =
INCLUDE_FILE_PATTERNS = INCLUDE_FILE_PATTERNS =
PREDEFINED = ASSIMP_DOXYGEN_BUILD=1 PREDEFINED = ASSIMP_DOXYGEN_BUILD=1
EXPAND_AS_DEFINED = C_STRUCT C_ENUM EXPAND_AS_DEFINED = C_STRUCT C_ENUM
SKIP_FUNCTION_MACROS = YES SKIP_FUNCTION_MACROS = YES
#endif #endif
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Doxygen gets confused if we use c-struct typedefs to avoid /* Doxygen gets confused if we use c-struct typedefs to avoid
* the explicit 'struct' notation. This trick here has the same * the explicit 'struct' notation. This trick here has the same
* effect as the TYPEDEF_HIDES_STRUCT option, but we don't need * effect as the TYPEDEF_HIDES_STRUCT option, but we don't need
* to typedef all structs/enums. */ * to typedef all structs/enums. */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
# if (defined ASSIMP_DOXYGEN_BUILD) # if (defined ASSIMP_DOXYGEN_BUILD)
# define C_STRUCT # define C_STRUCT
# define C_ENUM # define C_ENUM
# else # else
# define C_STRUCT struct # define C_STRUCT struct
# define C_ENUM enum # define C_ENUM enum
# endif # endif
#endif #endif
#if (defined(__BORLANDC__) || defined (__BCPLUSPLUS__)) #if (defined(__BORLANDC__) || defined (__BCPLUSPLUS__))
#error Currently, Borland is unsupported. Feel free to port Assimp. #error Currently, Borland is unsupported. Feel free to port Assimp.
// "W8059 Packgr<67><72>e der Struktur ge<67>ndert" // "W8059 Packgr<67><72>e der Struktur ge<67>ndert"
#endif #endif
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Define 'ASSIMP_BUILD_BOOST_WORKAROUND' to compile assimp /* Define 'ASSIMP_BUILD_BOOST_WORKAROUND' to compile assimp
* without boost. This is done by using a few workaround * without boost. This is done by using a few workaround
* classes and brings some limitations (e.g. some logging won't be done, * classes and brings some limitations (e.g. some logging won't be done,
* the library won't utilize threads or be threadsafe at all). * the library won't utilize threads or be threadsafe at all).
* This implies the 'ASSIMP_BUILD_SINGLETHREADED' setting. */ * This implies the 'ASSIMP_BUILD_SINGLETHREADED' setting. */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
#ifdef ASSIMP_BUILD_BOOST_WORKAROUND #ifdef ASSIMP_BUILD_BOOST_WORKAROUND
// threading support requires boost // threading support requires boost
#ifndef ASSIMP_BUILD_SINGLETHREADED #ifndef ASSIMP_BUILD_SINGLETHREADED
# define ASSIMP_BUILD_SINGLETHREADED # define ASSIMP_BUILD_SINGLETHREADED
#endif #endif
#endif // !! ASSIMP_BUILD_BOOST_WORKAROUND #endif // !! ASSIMP_BUILD_BOOST_WORKAROUND
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Define ASSIMP_BUILD_SINGLETHREADED to compile assimp /* Define ASSIMP_BUILD_SINGLETHREADED to compile assimp
* without threading support. The library doesn't utilize * without threading support. The library doesn't utilize
* threads then and is itself not threadsafe. * threads then and is itself not threadsafe.
* If this flag is specified boost::threads is *not* required. */ * If this flag is specified boost::threads is *not* required. */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
#ifndef ASSIMP_BUILD_SINGLETHREADED #ifndef ASSIMP_BUILD_SINGLETHREADED
# define ASSIMP_BUILD_SINGLETHREADED # define ASSIMP_BUILD_SINGLETHREADED
#endif #endif
#if defined(_DEBUG) || ! defined(NDEBUG) #if defined(_DEBUG) || ! defined(NDEBUG)
# define ASSIMP_BUILD_DEBUG # define ASSIMP_BUILD_DEBUG
#endif #endif
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Useful constants */ /* Useful constants */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* This is PI. Hi PI. */ /* This is PI. Hi PI. */
#define AI_MATH_PI (3.141592653589793238462643383279 ) #define AI_MATH_PI (3.141592653589793238462643383279 )
#define AI_MATH_TWO_PI (AI_MATH_PI * 2.0) #define AI_MATH_TWO_PI (AI_MATH_PI * 2.0)
#define AI_MATH_HALF_PI (AI_MATH_PI * 0.5) #define AI_MATH_HALF_PI (AI_MATH_PI * 0.5)
/* And this is to avoid endless casts to float */ /* And this is to avoid endless casts to float */
#define AI_MATH_PI_F (3.1415926538f) #define AI_MATH_PI_F (3.1415926538f)
#define AI_MATH_TWO_PI_F (AI_MATH_PI_F * 2.0f) #define AI_MATH_TWO_PI_F (AI_MATH_PI_F * 2.0f)
#define AI_MATH_HALF_PI_F (AI_MATH_PI_F * 0.5f) #define AI_MATH_HALF_PI_F (AI_MATH_PI_F * 0.5f)
/* Tiny macro to convert from radians to degrees and back */ /* Tiny macro to convert from radians to degrees and back */
#define AI_DEG_TO_RAD(x) ((x)*0.0174532925f) #define AI_DEG_TO_RAD(x) ((x)*0.0174532925f)
#define AI_RAD_TO_DEG(x) ((x)*57.2957795f) #define AI_RAD_TO_DEG(x) ((x)*57.2957795f)
/* Support for big-endian builds */ /* Support for big-endian builds */
#if defined(__BYTE_ORDER__) #if defined(__BYTE_ORDER__)
# if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) # if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
# if !defined(__BIG_ENDIAN__) # if !defined(__BIG_ENDIAN__)
# define __BIG_ENDIAN__ # define __BIG_ENDIAN__
# endif # endif
# else /* little endian */ # else /* little endian */
# if defined (__BIG_ENDIAN__) # if defined (__BIG_ENDIAN__)
# undef __BIG_ENDIAN__ # undef __BIG_ENDIAN__
# endif # endif
# endif # endif
#endif #endif
#if defined(__BIG_ENDIAN__) #if defined(__BIG_ENDIAN__)
# define AI_BUILD_BIG_ENDIAN # define AI_BUILD_BIG_ENDIAN
#endif #endif
#endif // !! INCLUDED_AI_DEFINES_H #endif // !! INCLUDED_AI_DEFINES_H

286
include/assimp/importerdesc.h
View File

@ -1,143 +1,143 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file importerdesc.h /** @file importerdesc.h
* @brief #aiImporterFlags, aiImporterDesc implementation. * @brief #aiImporterFlags, aiImporterDesc implementation.
*/ */
#ifndef INCLUDED_AI_IMPORTER_DESC_H #ifndef INCLUDED_AI_IMPORTER_DESC_H
#define INCLUDED_AI_IMPORTER_DESC_H #define INCLUDED_AI_IMPORTER_DESC_H
/** 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,
/** Indicates that there is a binary encoding of the /** Indicates that there is a binary encoding of the
* file format; and that it is supported.*/ * file format; and that it is supported.*/
aiImporterFlags_SupportBinaryFlavour = 0x2, aiImporterFlags_SupportBinaryFlavour = 0x2,
/** Indicates that there is a compressed encoding of the /** Indicates that there is a compressed encoding of the
* file format; and that it is supported.*/ * file format; and that it is supported.*/
aiImporterFlags_SupportCompressedFlavour = 0x4, aiImporterFlags_SupportCompressedFlavour = 0x4,
/** Indicates that the importer reads only a very particular /** Indicates that the importer reads only a very particular
* subset of the file format. This happens commonly for * subset of the file format. This happens commonly for
* declarative or procedural formats which cannot easily * declarative or procedural formats which cannot easily
* be mapped to #aiScene */ * be mapped to #aiScene */
aiImporterFlags_LimitedSupport = 0x8, aiImporterFlags_LimitedSupport = 0x8,
/** Indicates that the importer is highly experimental and /** Indicates that the importer is highly experimental and
* should be used with care. This only happens for trunk * should be used with care. This only happens for trunk
* (i.e. SVN) versions, experimental code is not included * (i.e. SVN) versions, experimental code is not included
* in releases. */ * in releases. */
aiImporterFlags_Experimental = 0x10 aiImporterFlags_Experimental = 0x10
}; };
/** Meta information about a particular importer. Importers need to fill /** Meta information about a particular importer. Importers need to fill
* this structure, but they can freely decide how talkative they are. * this structure, but they can freely decide how talkative they are.
* A common use case for loader meta info is a user interface * A common use case for loader meta info is a user interface
* in which the user can choose between various import/export file * in which the user can choose between various import/export file
* formats. Building such an UI by hand means a lot of maintenance * formats. Building such an UI by hand means a lot of maintenance
* 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;
/** Original author (left blank if unknown or whole assimp team) */ /** Original author (left blank if unknown or whole assimp team) */
const char* mAuthor; const char* mAuthor;
/** Current maintainer, left blank if the author maintains */ /** Current maintainer, left blank if the author maintains */
const char* mMaintainer; const char* mMaintainer;
/** Implementation comments, i.e. unimplemented features*/ /** Implementation comments, i.e. unimplemented features*/
const char* mComments; const char* mComments;
/** These flags indicate some characteristics common to many /** These flags indicate some characteristics common to many
importers. */ importers. */
unsigned int mFlags; unsigned int mFlags;
/** Minimum format version that can be loaded im major.minor format, /** Minimum format version that can be loaded im major.minor format,
both are set to 0 if there is either no version scheme both are set to 0 if there is either no version scheme
or if the loader doesn't care. */ or if the loader doesn't care. */
unsigned int mMinMajor; unsigned int mMinMajor;
unsigned int mMinMinor; unsigned int mMinMinor;
/** Maximum format version that can be loaded im major.minor format, /** Maximum format version that can be loaded im major.minor format,
both are set to 0 if there is either no version scheme both are set to 0 if there is either no version scheme
or if the loader doesn't care. Loaders that expect to be or if the loader doesn't care. Loaders that expect to be
forward-compatible to potential future format versions should forward-compatible to potential future format versions should
indicate zero, otherwise they should specify the current indicate zero, otherwise they should specify the current
maximum version.*/ maximum version.*/
unsigned int mMaxMajor; unsigned int mMaxMajor;
unsigned int mMaxMinor; unsigned int mMaxMinor;
/** List of file extensions this importer can handle. /** List of file extensions this importer can handle.
List entries are separated by space characters. List entries are separated by space characters.
All entries are lower case without a leading dot (i.e. All entries are lower case without a leading dot (i.e.
"xml dae" would be a valid value. Note that multiple "xml dae" would be a valid value. Note that multiple
importers may respond to the same file extension - importers may respond to the same file extension -
assimp calls all importers in the order in which they assimp calls all importers in the order in which they
are registered and each importer gets the opportunity are registered and each importer gets the opportunity
to load the file until one importer "claims" the file. Apart to load the file until one importer "claims" the file. Apart
from file extension checks, importers typically use from file extension checks, importers typically use
other methods to quickly reject files (i.e. magic other methods to quickly reject files (i.e. magic
words) so this does not mean that common or generic words) so this does not mean that common or generic
file extensions such as XML would be tediously slow. */ file extensions such as XML would be tediously slow. */
const char* mFileExtensions; const char* mFileExtensions;
}; };
/** \brief Returns the Importer description for a given extension. /** \brief Returns the Importer description for a given extension.
Will return a NULL-pointer if no assigned importer desc. was found for the given extension Will return a NULL-pointer if no assigned importer desc. was found for the given extension
\param extension [in] The extension to look for \param extension [in] The extension to look for
\return A pointer showing to the ImporterDesc, \see aiImporterDesc. \return A pointer showing to the ImporterDesc, \see aiImporterDesc.
*/ */
ASSIMP_API const C_STRUCT aiImporterDesc* aiGetImporterDesc( const char *extension ); ASSIMP_API const C_STRUCT aiImporterDesc* aiGetImporterDesc( const char *extension );
#endif #endif

480
include/assimp/light.h
View File

@ -1,240 +1,240 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file light.h /** @file light.h
* @brief Defines the aiLight data structure * @brief Defines the aiLight data structure
*/ */
#ifndef __AI_LIGHT_H_INC__ #ifndef __AI_LIGHT_H_INC__
#define __AI_LIGHT_H_INC__ #define __AI_LIGHT_H_INC__
#include "types.h" #include "types.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Enumerates all supported types of light sources. /** Enumerates all supported types of light sources.
*/ */
enum aiLightSourceType enum aiLightSourceType
{ {
aiLightSource_UNDEFINED = 0x0, aiLightSource_UNDEFINED = 0x0,
//! A directional light source has a well-defined direction //! A directional light source has a well-defined direction
//! but is infinitely far away. That's quite a good //! but is infinitely far away. That's quite a good
//! approximation for sun light. //! approximation for sun light.
aiLightSource_DIRECTIONAL = 0x1, aiLightSource_DIRECTIONAL = 0x1,
//! A point light source has a well-defined position //! A point light source has a well-defined position
//! in space but no direction - it emits light in all //! in space but no direction - it emits light in all
//! directions. A normal bulb is a point light. //! directions. A normal bulb is a point light.
aiLightSource_POINT = 0x2, aiLightSource_POINT = 0x2,
//! A spot light source emits light in a specific //! A spot light source emits light in a specific
//! angle. It has a position and a direction it is pointing to. //! angle. It has a position and a direction it is pointing to.
//! A good example for a spot light is a light spot in //! A good example for a spot light is a light spot in
//! sport arenas. //! sport arenas.
aiLightSource_SPOT = 0x3, aiLightSource_SPOT = 0x3,
//! The generic light level of the world, including the bounces //! The generic light level of the world, including the bounces
//! of all other lightsources. //! of all other lightsources.
//! Typically, there's at most one ambient light in a scene. //! Typically, there's at most one ambient light in a scene.
//! This light type doesn't have a valid position, direction, or //! This light type doesn't have a valid position, direction, or
//! other properties, just a color. //! other properties, just a color.
aiLightSource_AMBIENT = 0x4, aiLightSource_AMBIENT = 0x4,
/** This value is not used. It is just there to force the /** This value is not used. It is just there to force the
* compiler to map this enum to a 32 Bit integer. * compiler to map this enum to a 32 Bit integer.
*/ */
#ifndef SWIG #ifndef SWIG
_aiLightSource_Force32Bit = INT_MAX _aiLightSource_Force32Bit = INT_MAX
#endif #endif
}; };
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Helper structure to describe a light source. /** Helper structure to describe a light source.
* *
* Assimp supports multiple sorts of light sources, including * Assimp supports multiple sorts of light sources, including
* directional, point and spot lights. All of them are defined with just * directional, point and spot lights. All of them are defined with just
* a single structure and distinguished by their parameters. * a single structure and distinguished by their parameters.
* Note - some file formats (such as 3DS, ASE) export a "target point" - * Note - some file formats (such as 3DS, ASE) export a "target point" -
* the point a spot light is looking at (it can even be animated). Assimp * the point a spot light is looking at (it can even be animated). Assimp
* writes the target point as a subnode of a spotlights's main node, * writes the target point as a subnode of a spotlights's main node,
* called "<spotName>.Target". However, this is just additional information * called "<spotName>.Target". However, this is just additional information
* then, the transformation tracks of the main node make the * then, the transformation tracks of the main node make the
* spot light already point in the right direction. * spot light already point in the right direction.
*/ */
struct aiLight struct aiLight
{ {
/** The name of the light source. /** The name of the light source.
* *
* There must be a node in the scenegraph with the same name. * There must be a node in the scenegraph with the same name.
* This node specifies the position of the light in the scene * This node specifies the position of the light in the scene
* hierarchy and can be animated. * hierarchy and can be animated.
*/ */
C_STRUCT aiString mName; C_STRUCT aiString mName;
/** The type of the light source. /** The type of the light source.
* *
* aiLightSource_UNDEFINED is not a valid value for this member. * aiLightSource_UNDEFINED is not a valid value for this member.
*/ */
C_ENUM aiLightSourceType mType; C_ENUM aiLightSourceType mType;
/** Position of the light source in space. Relative to the /** Position of the light source in space. Relative to the
* transformation of the node corresponding to the light. * transformation of the node corresponding to the light.
* *
* The position is undefined for directional lights. * The position is undefined for directional lights.
*/ */
C_STRUCT aiVector3D mPosition; C_STRUCT aiVector3D mPosition;
/** Direction of the light source in space. Relative to the /** Direction of the light source in space. Relative to the
* transformation of the node corresponding to the light. * transformation of the node corresponding to the light.
* *
* The direction is undefined for point lights. The vector * The direction is undefined for point lights. The vector
* may be normalized, but it needn't. * may be normalized, but it needn't.
*/ */
C_STRUCT aiVector3D mDirection; C_STRUCT aiVector3D mDirection;
/** Constant light attenuation factor. /** Constant light attenuation factor.
* *
* The intensity of the light source at a given distance 'd' from * The intensity of the light source at a given distance 'd' from
* the light's position is * the light's position is
* @code * @code
* Atten = 1/( att0 + att1 * d + att2 * d*d) * Atten = 1/( att0 + att1 * d + att2 * d*d)
* @endcode * @endcode
* This member corresponds to the att0 variable in the equation. * This member corresponds to the att0 variable in the equation.
* Naturally undefined for directional lights. * Naturally undefined for directional lights.
*/ */
float mAttenuationConstant; float mAttenuationConstant;
/** Linear light attenuation factor. /** Linear light attenuation factor.
* *
* The intensity of the light source at a given distance 'd' from * The intensity of the light source at a given distance 'd' from
* the light's position is * the light's position is
* @code * @code
* Atten = 1/( att0 + att1 * d + att2 * d*d) * Atten = 1/( att0 + att1 * d + att2 * d*d)
* @endcode * @endcode
* This member corresponds to the att1 variable in the equation. * This member corresponds to the att1 variable in the equation.
* Naturally undefined for directional lights. * Naturally undefined for directional lights.
*/ */
float mAttenuationLinear; float mAttenuationLinear;
/** Quadratic light attenuation factor. /** Quadratic light attenuation factor.
* *
* The intensity of the light source at a given distance 'd' from * The intensity of the light source at a given distance 'd' from
* the light's position is * the light's position is
* @code * @code
* Atten = 1/( att0 + att1 * d + att2 * d*d) * Atten = 1/( att0 + att1 * d + att2 * d*d)
* @endcode * @endcode
* This member corresponds to the att2 variable in the equation. * This member corresponds to the att2 variable in the equation.
* Naturally undefined for directional lights. * Naturally undefined for directional lights.
*/ */
float mAttenuationQuadratic; float mAttenuationQuadratic;
/** Diffuse color of the light source /** Diffuse color of the light source
* *
* The diffuse light color is multiplied with the diffuse * The diffuse light color is multiplied with the diffuse
* material color to obtain the final color that contributes * material color to obtain the final color that contributes
* to the diffuse shading term. * to the diffuse shading term.
*/ */
C_STRUCT aiColor3D mColorDiffuse; C_STRUCT aiColor3D mColorDiffuse;
/** Specular color of the light source /** Specular color of the light source
* *
* The specular light color is multiplied with the specular * The specular light color is multiplied with the specular
* material color to obtain the final color that contributes * material color to obtain the final color that contributes
* to the specular shading term. * to the specular shading term.
*/ */
C_STRUCT aiColor3D mColorSpecular; C_STRUCT aiColor3D mColorSpecular;
/** Ambient color of the light source /** Ambient color of the light source
* *
* The ambient light color is multiplied with the ambient * The ambient light color is multiplied with the ambient
* material color to obtain the final color that contributes * material color to obtain the final color that contributes
* to the ambient shading term. Most renderers will ignore * to the ambient shading term. Most renderers will ignore
* this value it, is just a remaining of the fixed-function pipeline * this value it, is just a remaining of the fixed-function pipeline
* that is still supported by quite many file formats. * that is still supported by quite many file formats.
*/ */
C_STRUCT aiColor3D mColorAmbient; C_STRUCT aiColor3D mColorAmbient;
/** Inner angle of a spot light's light cone. /** Inner angle of a spot light's light cone.
* *
* The spot light has maximum influence on objects inside this * The spot light has maximum influence on objects inside this
* angle. The angle is given in radians. It is 2PI for point * angle. The angle is given in radians. It is 2PI for point
* lights and undefined for directional lights. * lights and undefined for directional lights.
*/ */
float mAngleInnerCone; float mAngleInnerCone;
/** Outer angle of a spot light's light cone. /** Outer angle of a spot light's light cone.
* *
* The spot light does not affect objects outside this angle. * The spot light does not affect objects outside this angle.
* The angle is given in radians. It is 2PI for point lights and * The angle is given in radians. It is 2PI for point lights and
* undefined for directional lights. The outer angle must be * undefined for directional lights. The outer angle must be
* greater than or equal to the inner angle. * greater than or equal to the inner angle.
* It is assumed that the application uses a smooth * It is assumed that the application uses a smooth
* interpolation between the inner and the outer cone of the * interpolation between the inner and the outer cone of the
* spot light. * spot light.
*/ */
float mAngleOuterCone; float mAngleOuterCone;
#ifdef __cplusplus #ifdef __cplusplus
aiLight() aiLight()
: mType (aiLightSource_UNDEFINED) : mType (aiLightSource_UNDEFINED)
, mAttenuationConstant (0.f) , mAttenuationConstant (0.f)
, mAttenuationLinear (1.f) , mAttenuationLinear (1.f)
, mAttenuationQuadratic (0.f) , mAttenuationQuadratic (0.f)
, mAngleInnerCone ((float)AI_MATH_TWO_PI) , mAngleInnerCone ((float)AI_MATH_TWO_PI)
, mAngleOuterCone ((float)AI_MATH_TWO_PI) , mAngleOuterCone ((float)AI_MATH_TWO_PI)
{ {
} }
#endif #endif
}; };
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif // !! __AI_LIGHT_H_INC__ #endif // !! __AI_LIGHT_H_INC__

3084
include/assimp/material.h
View File

File diff suppressed because it is too large Load Diff

700
include/assimp/material.inl
View File

@ -1,350 +1,350 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file material.inl /** @file material.inl
* @brief Defines the C++ getters for the material system * @brief Defines the C++ getters for the material system
*/ */
#ifndef AI_MATERIAL_INL_INC #ifndef AI_MATERIAL_INL_INC
#define AI_MATERIAL_INL_INC #define AI_MATERIAL_INL_INC
//! @cond never //! @cond never
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::GetTexture( aiTextureType type, inline aiReturn aiMaterial::GetTexture( aiTextureType type,
unsigned int index, unsigned int index,
C_STRUCT aiString* path, C_STRUCT aiString* path,
aiTextureMapping* mapping /*= NULL*/, aiTextureMapping* mapping /*= NULL*/,
unsigned int* uvindex /*= NULL*/, unsigned int* uvindex /*= NULL*/,
float* blend /*= NULL*/, float* blend /*= NULL*/,
aiTextureOp* op /*= NULL*/, aiTextureOp* op /*= NULL*/,
aiTextureMapMode* mapmode /*= NULL*/) const 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 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, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx, Type* pOut, unsigned int idx, Type* pOut,
unsigned int* pMax) const unsigned int* pMax) const
{ {
unsigned int iNum = pMax ? *pMax : 1; unsigned int iNum = pMax ? *pMax : 1;
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);
if ( AI_SUCCESS == ret ) { if ( AI_SUCCESS == ret ) {
if (prop->mDataLength < sizeof(Type)*iNum) { if (prop->mDataLength < sizeof(Type)*iNum) {
return AI_FAILURE; return AI_FAILURE;
} }
if (prop->mType != aiPTI_Buffer) { if (prop->mType != aiPTI_Buffer) {
return AI_FAILURE; return AI_FAILURE;
} }
iNum = std::min((size_t)iNum,prop->mDataLength / sizeof(Type)); iNum = std::min((size_t)iNum,prop->mDataLength / sizeof(Type));
::memcpy(pOut,prop->mData,iNum * sizeof(Type)); ::memcpy(pOut,prop->mData,iNum * sizeof(Type));
if (pMax) { if (pMax) {
*pMax = iNum; *pMax = iNum;
} }
} }
return ret; return ret;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template <typename Type> template <typename Type>
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,Type& pOut) const 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);
if ( AI_SUCCESS == ret ) { if ( AI_SUCCESS == ret ) {
if (prop->mDataLength < sizeof(Type)) { if (prop->mDataLength < sizeof(Type)) {
return AI_FAILURE; return AI_FAILURE;
} }
if (prop->mType != aiPTI_Buffer) { if (prop->mType != aiPTI_Buffer) {
return AI_FAILURE; return AI_FAILURE;
} }
::memcpy(&pOut,prop->mData,sizeof(Type)); ::memcpy(&pOut,prop->mData,sizeof(Type));
} }
return ret; return ret;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,float* pOut, unsigned int idx,float* pOut,
unsigned int* pMax) const 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, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,int* pOut, unsigned int idx,int* pOut,
unsigned int* pMax) const 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, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,float& pOut) const unsigned int idx,float& 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, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,int& pOut) const 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, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,aiColor4D& pOut) const 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, 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, 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, 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,
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(TYPE), pNumValues * sizeof(TYPE),
pKey,type,index,aiPTI_Buffer); pKey,type,index,aiPTI_Buffer);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const float* pInput, 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 aiUVTransform* pInput, inline aiReturn aiMaterial::AddProperty(const aiUVTransform* 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(aiUVTransform), pNumValues * sizeof(aiUVTransform),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const aiColor4D* pInput, inline aiReturn aiMaterial::AddProperty(const aiColor4D* 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(aiColor4D), pNumValues * sizeof(aiColor4D),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const aiColor3D* pInput, inline aiReturn aiMaterial::AddProperty(const aiColor3D* 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(aiColor3D), pNumValues * sizeof(aiColor3D),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const aiVector3D* pInput, inline aiReturn aiMaterial::AddProperty(const aiVector3D* 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(aiVector3D), pNumValues * sizeof(aiVector3D),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const int* pInput, inline aiReturn aiMaterial::AddProperty(const int* 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(int), pNumValues * sizeof(int),
pKey,type,index,aiPTI_Integer); pKey,type,index,aiPTI_Integer);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// The template specializations below are for backwards compatibility. // The template specializations below are for backwards compatibility.
// The recommended way to add material properties is using the non-template // The recommended way to add material properties is using the non-template
// overloads. // overloads.
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<float>(const float* pInput, inline aiReturn aiMaterial::AddProperty<float>(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);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput, inline aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* 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(aiUVTransform), pNumValues * sizeof(aiUVTransform),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput, inline aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* 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(aiColor4D), pNumValues * sizeof(aiColor4D),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput, inline aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* 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(aiColor3D), pNumValues * sizeof(aiColor3D),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput, inline aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* 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(aiVector3D), pNumValues * sizeof(aiVector3D),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<int>(const int* pInput, inline aiReturn aiMaterial::AddProperty<int>(const int* 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(int), pNumValues * sizeof(int),
pKey,type,index,aiPTI_Integer); pKey,type,index,aiPTI_Integer);
} }
//! @endcond //! @endcond
#endif //! AI_MATERIAL_INL_INC #endif //! AI_MATERIAL_INL_INC

370
include/assimp/matrix3x3.h
View File

@ -1,185 +1,185 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file matrix3x3.h /** @file matrix3x3.h
* @brief Definition of a 3x3 matrix, including operators when compiling in C++ * @brief Definition of a 3x3 matrix, including operators when compiling in C++
*/ */
#ifndef AI_MATRIX3x3_H_INC #ifndef AI_MATRIX3x3_H_INC
#define AI_MATRIX3x3_H_INC #define AI_MATRIX3x3_H_INC
#include "./Compiler/pushpack1.h" #include "./Compiler/pushpack1.h"
#ifdef __cplusplus #ifdef __cplusplus
template <typename T> class aiMatrix4x4t; template <typename T> class aiMatrix4x4t;
template <typename T> class aiVector2t; template <typename T> class aiVector2t;
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Represents a row-major 3x3 matrix /** @brief Represents a row-major 3x3 matrix
* *
* There's much confusion about matrix layouts (column vs. row order). * There's much confusion about matrix layouts (column vs. row order).
* This is *always* a row-major matrix. Not even with the * This is *always* a row-major matrix. Not even with the
* #aiProcess_ConvertToLeftHanded flag, which absolutely does not affect * #aiProcess_ConvertToLeftHanded flag, which absolutely does not affect
* matrix order - it just affects the handedness of the coordinate system * matrix order - it just affects the handedness of the coordinate system
* defined thereby. * defined thereby.
*/ */
template <typename TReal> template <typename TReal>
class aiMatrix3x3t class aiMatrix3x3t
{ {
public: public:
aiMatrix3x3t () : aiMatrix3x3t () :
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(),
c1(), c2(), c3(static_cast<TReal>(1.0f)) {} c1(), c2(), c3(static_cast<TReal>(1.0f)) {}
aiMatrix3x3t ( TReal _a1, TReal _a2, TReal _a3, aiMatrix3x3t ( TReal _a1, TReal _a2, TReal _a3,
TReal _b1, TReal _b2, TReal _b3, TReal _b1, TReal _b2, TReal _b3,
TReal _c1, TReal _c2, TReal _c3) : TReal _c1, TReal _c2, TReal _c3) :
a1(_a1), a2(_a2), a3(_a3), a1(_a1), a2(_a2), a3(_a3),
b1(_b1), b2(_b2), b3(_b3), b1(_b1), b2(_b2), b3(_b3),
c1(_c1), c2(_c2), c3(_c3) c1(_c1), c2(_c2), c3(_c3)
{} {}
public: 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;
// array access operators // array access operators
TReal* operator[] (unsigned int p_iIndex); TReal* operator[] (unsigned int p_iIndex);
const TReal* operator[] (unsigned int p_iIndex) const; const TReal* operator[] (unsigned int p_iIndex) const;
// comparison operators // comparison operators
bool operator== (const aiMatrix4x4t<TReal>& m) const; bool operator== (const aiMatrix4x4t<TReal>& m) const;
bool operator!= (const aiMatrix4x4t<TReal>& m) const; bool operator!= (const aiMatrix4x4t<TReal>& m) const;
bool Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon = 1e-6) const; bool Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon = 1e-6) const;
template <typename TOther> template <typename TOther>
operator aiMatrix3x3t<TOther> () const; operator aiMatrix3x3t<TOther> () const;
public: 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.
*/ */
explicit aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix); explicit aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Transpose the matrix /** @brief Transpose the matrix
*/ */
aiMatrix3x3t& Transpose(); aiMatrix3x3t& Transpose();
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Invert the matrix. /** @brief Invert the matrix.
* If the matrix is not invertible all elements are set to qnan. * If the matrix is not invertible all elements are set to qnan.
* Beware, use (f != f) to check whether a TReal f is qnan. * Beware, use (f != f) to check whether a TReal f is qnan.
*/ */
aiMatrix3x3t& Inverse(); aiMatrix3x3t& Inverse();
TReal Determinant() const; TReal Determinant() const;
public: 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
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix3x3t& RotationZ(TReal a, aiMatrix3x3t& out); static aiMatrix3x3t& RotationZ(TReal a, aiMatrix3x3t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a rotation matrix for a rotation around /** @brief Returns a rotation matrix for a rotation around
* an arbitrary axis. * an arbitrary axis.
* *
* @param a Rotation angle, in radians * @param a Rotation angle, in radians
* @param axis Axis to rotate around * @param axis Axis to rotate around
* @param out To be filled * @param out To be filled
*/ */
static aiMatrix3x3t& Rotation( TReal a, static aiMatrix3x3t& Rotation( TReal a,
const aiVector3t<TReal>& axis, aiMatrix3x3t& out); const aiVector3t<TReal>& axis, aiMatrix3x3t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a translation matrix /** @brief Returns a translation matrix
* @param v Translation vector * @param v Translation vector
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix3x3t& Translation( const aiVector2t<TReal>& v, aiMatrix3x3t& out); static aiMatrix3x3t& Translation( const aiVector2t<TReal>& v, aiMatrix3x3t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief A function for creating a rotation matrix that rotates a /** @brief A function for creating a rotation matrix that rotates a
* vector called "from" into another vector called "to". * vector called "from" into another vector called "to".
* Input : from[3], to[3] which both must be *normalized* non-zero vectors * Input : from[3], to[3] which both must be *normalized* non-zero vectors
* Output: mtx[3][3] -- a 3x3 matrix in colum-major form * Output: mtx[3][3] -- a 3x3 matrix in colum-major form
* Authors: Tomas Möller, John Hughes * Authors: Tomas Möller, John Hughes
* "Efficiently Building a Matrix to Rotate One Vector to Another" * "Efficiently Building a Matrix to Rotate One Vector to Another"
* Journal of Graphics Tools, 4(4):1-4, 1999 * Journal of Graphics Tools, 4(4):1-4, 1999
*/ */
static aiMatrix3x3t& FromToMatrix(const aiVector3t<TReal>& from, static aiMatrix3x3t& FromToMatrix(const aiVector3t<TReal>& from,
const aiVector3t<TReal>& to, aiMatrix3x3t& out); const aiVector3t<TReal>& to, aiMatrix3x3t& out);
public: public:
TReal a1, a2, a3; TReal a1, a2, a3;
TReal b1, b2, b3; TReal b1, b2, b3;
TReal c1, c2, c3; TReal c1, c2, c3;
} PACK_STRUCT; } PACK_STRUCT;
typedef aiMatrix3x3t<float> aiMatrix3x3; typedef aiMatrix3x3t<float> aiMatrix3x3;
#else #else
struct aiMatrix3x3 { struct aiMatrix3x3 {
float a1, a2, a3; float a1, a2, a3;
float b1, b2, b3; float b1, b2, b3;
float c1, c2, c3; float c1, c2, c3;
} PACK_STRUCT; } PACK_STRUCT;
#endif #endif
#include "./Compiler/poppack1.h" #include "./Compiler/poppack1.h"
#endif // AI_MATRIX3x3_H_INC #endif // AI_MATRIX3x3_H_INC

664
include/assimp/matrix3x3.inl
View File

@ -1,332 +1,332 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file matrix3x3.inl /** @file matrix3x3.inl
* @brief Inline implementation of the 3x3 matrix operators * @brief Inline implementation of the 3x3 matrix operators
*/ */
#ifndef AI_MATRIX3x3_INL_INC #ifndef AI_MATRIX3x3_INL_INC
#define AI_MATRIX3x3_INL_INC #define AI_MATRIX3x3_INL_INC
#ifdef __cplusplus #ifdef __cplusplus
#include "matrix3x3.h" #include "matrix3x3.h"
#include "matrix4x4.h" #include "matrix4x4.h"
#include <algorithm> #include <algorithm>
#include <cmath> #include <cmath>
#include <limits> #include <limits>
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// 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) 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;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& m) 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,
m.a1 * b1 + m.b1 * b2 + m.c1 * b3, m.a1 * b1 + m.b1 * b2 + m.c1 * b3,
m.a2 * b1 + m.b2 * b2 + m.c2 * b3, m.a2 * b1 + m.b2 * b2 + m.c2 * b3,
m.a3 * b1 + m.b3 * b2 + m.c3 * b3, m.a3 * b1 + m.b3 * b2 + m.c3 * b3,
m.a1 * c1 + m.b1 * c2 + m.c1 * c3, m.a1 * c1 + m.b1 * c2 + m.c1 * c3,
m.a2 * c1 + m.b2 * c2 + m.c2 * c3, m.a2 * c1 + m.b2 * c2 + m.c2 * c3,
m.a3 * c1 + m.b3 * c2 + m.c3 * c3); m.a3 * c1 + m.b3 * c2 + m.c3 * c3);
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
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));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal> aiMatrix3x3t<TReal>::operator* (const aiMatrix3x3t<TReal>& m) const 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;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) inline TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex)
{ {
return &this->a1 + p_iIndex * 3; return &this->a1 + p_iIndex * 3;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) const inline const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) const
{ {
return &this->a1 + p_iIndex * 3; return &this->a1 + p_iIndex * 3;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline bool aiMatrix3x3t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const 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;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline bool aiMatrix3x3t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const 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 { 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 &&
std::abs(a3 - m.a3) <= epsilon && std::abs(a3 - m.a3) <= epsilon &&
std::abs(b1 - m.b1) <= epsilon && std::abs(b1 - m.b1) <= epsilon &&
std::abs(b2 - m.b2) <= epsilon && std::abs(b2 - m.b2) <= epsilon &&
std::abs(b3 - m.b3) <= epsilon && std::abs(b3 - m.b3) <= epsilon &&
std::abs(c1 - m.c1) <= epsilon && std::abs(c1 - m.c1) <= epsilon &&
std::abs(c2 - m.c2) <= epsilon && std::abs(c2 - m.c2) <= epsilon &&
std::abs(c3 - m.c3) <= epsilon; std::abs(c3 - m.c3) <= epsilon;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Transpose() 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);
std::swap( (TReal&)b3, (TReal&)c2); std::swap( (TReal&)b3, (TReal&)c2);
return *this; return *this;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline TReal aiMatrix3x3t<TReal>::Determinant() const 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() 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))
{ {
// Matrix not invertible. Setting all elements to nan is not really // Matrix not invertible. Setting all elements to nan is not really
// correct in a mathematical sense; but at least qnans are easy to // correct in a mathematical sense; but at least qnans are easy to
// spot. XXX we might throw an exception instead, which would // spot. XXX we might throw an exception instead, which would
// be even much better to spot :/. // be even much better to spot :/.
const TReal nan = std::numeric_limits<TReal>::quiet_NaN(); const TReal nan = std::numeric_limits<TReal>::quiet_NaN();
*this = aiMatrix3x3t<TReal>( nan,nan,nan,nan,nan,nan,nan,nan,nan); *this = aiMatrix3x3t<TReal>( nan,nan,nan,nan,nan,nan,nan,nan,nan);
return *this; return *this;
} }
TReal invdet = static_cast<TReal>(1.0) / det; TReal invdet = static_cast<TReal>(1.0) / det;
aiMatrix3x3t<TReal> res; aiMatrix3x3t<TReal> res;
res.a1 = invdet * (b2 * c3 - b3 * c2); res.a1 = invdet * (b2 * c3 - b3 * c2);
res.a2 = -invdet * (a2 * c3 - a3 * c2); res.a2 = -invdet * (a2 * c3 - a3 * c2);
res.a3 = invdet * (a2 * b3 - a3 * b2); res.a3 = invdet * (a2 * b3 - a3 * b2);
res.b1 = -invdet * (b1 * c3 - b3 * c1); res.b1 = -invdet * (b1 * c3 - b3 * c1);
res.b2 = invdet * (a1 * c3 - a3 * c1); res.b2 = invdet * (a1 * c3 - a3 * c1);
res.b3 = -invdet * (a1 * b3 - a3 * b1); res.b3 = -invdet * (a1 * b3 - a3 * b1);
res.c1 = invdet * (b1 * c2 - b2 * c1); res.c1 = invdet * (b1 * c2 - b2 * c1);
res.c2 = -invdet * (a1 * c2 - a2 * c1); res.c2 = -invdet * (a1 * c2 - a2 * c1);
res.c3 = invdet * (a1 * b2 - a2 * b1); res.c3 = invdet * (a1 * b2 - a2 * b1);
*this = res; *this = res;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::RotationZ(TReal a, aiMatrix3x3t<TReal>& out) 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;
out.a3 = out.b3 = out.c1 = out.c2 = 0.f; out.a3 = out.b3 = out.c1 = out.c2 = 0.f;
out.c3 = 1.f; out.c3 = 1.f;
return out; return out;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// 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) 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;
// 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;
return out; return out;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<TReal>& v, aiMatrix3x3t<TReal>& out) 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;
return out; return out;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
/** A function for creating a rotation matrix that rotates a vector called /** A function for creating a rotation matrix that rotates a vector called
* "from" into another vector called "to". * "from" into another vector called "to".
* Input : from[3], to[3] which both must be *normalized* non-zero vectors * Input : from[3], to[3] which both must be *normalized* non-zero vectors
* Output: mtx[3][3] -- a 3x3 matrix in colum-major form * Output: mtx[3][3] -- a 3x3 matrix in colum-major form
* Authors: Tomas Möller, John Hughes * Authors: Tomas Möller, John Hughes
* "Efficiently Building a Matrix to Rotate One Vector to Another" * "Efficiently Building a Matrix to Rotate One Vector to Another"
* Journal of Graphics Tools, 4(4):1-4, 1999 * Journal of Graphics Tools, 4(4):1-4, 1999
*/ */
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::FromToMatrix(const aiVector3t<TReal>& from, 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;
if (f > static_cast<TReal>(1.0) - static_cast<TReal>(0.00001)) /* "from" and "to"-vector almost parallel */ if (f > static_cast<TReal>(1.0) - static_cast<TReal>(0.00001)) /* "from" and "to"-vector almost parallel */
{ {
aiVector3D u,v; /* temporary storage vectors */ aiVector3D u,v; /* temporary storage vectors */
aiVector3D x; /* vector most nearly orthogonal to "from" */ aiVector3D x; /* vector most nearly orthogonal to "from" */
x.x = (from.x > 0.0)? from.x : -from.x; x.x = (from.x > 0.0)? from.x : -from.x;
x.y = (from.y > 0.0)? from.y : -from.y; x.y = (from.y > 0.0)? from.y : -from.y;
x.z = (from.z > 0.0)? from.z : -from.z; x.z = (from.z > 0.0)? from.z : -from.z;
if (x.x < x.y) if (x.x < x.y)
{ {
if (x.x < x.z) if (x.x < x.z)
{ {
x.x = static_cast<TReal>(1.0); x.y = x.z = static_cast<TReal>(0.0); x.x = static_cast<TReal>(1.0); x.y = x.z = static_cast<TReal>(0.0);
} }
else else
{ {
x.z = static_cast<TReal>(1.0); x.y = x.z = static_cast<TReal>(0.0); x.z = static_cast<TReal>(1.0); x.y = x.z = static_cast<TReal>(0.0);
} }
} }
else else
{ {
if (x.y < x.z) if (x.y < x.z)
{ {
x.y = static_cast<TReal>(1.0); x.x = x.z = static_cast<TReal>(0.0); x.y = static_cast<TReal>(1.0); x.x = x.z = static_cast<TReal>(0.0);
} }
else else
{ {
x.z = static_cast<TReal>(1.0); x.x = x.y = static_cast<TReal>(0.0); x.z = static_cast<TReal>(1.0); x.x = x.y = static_cast<TReal>(0.0);
} }
} }
u.x = x.x - from.x; u.y = x.y - from.y; u.z = x.z - from.z; u.x = x.x - from.x; u.y = x.y - from.y; u.z = x.z - from.z;
v.x = x.x - to.x; v.y = x.y - to.y; v.z = x.z - to.z; v.x = x.x - to.x; v.y = x.y - to.y; v.z = x.z - to.z;
const TReal c1 = static_cast<TReal>(2.0) / (u * u); const TReal c1 = static_cast<TReal>(2.0) / (u * u);
const TReal c2 = static_cast<TReal>(2.0) / (v * v); const TReal c2 = static_cast<TReal>(2.0) / (v * v);
const TReal c3 = c1 * c2 * (u * v); const TReal c3 = c1 * c2 * (u * v);
for (unsigned int i = 0; i < 3; i++) for (unsigned int i = 0; i < 3; i++)
{ {
for (unsigned int j = 0; j < 3; j++) for (unsigned int j = 0; j < 3; j++)
{ {
mtx[i][j] = - c1 * u[i] * u[j] - c2 * v[i] * v[j] mtx[i][j] = - c1 * u[i] * u[j] - c2 * v[i] * v[j]
+ c3 * v[i] * u[j]; + c3 * v[i] * u[j];
} }
mtx[i][i] += static_cast<TReal>(1.0); mtx[i][i] += static_cast<TReal>(1.0);
} }
} }
else /* the most common case, unless "from"="to", or "from"=-"to" */ else /* the most common case, unless "from"="to", or "from"=-"to" */
{ {
const aiVector3D v = from ^ to; const aiVector3D v = from ^ to;
/* ... use this hand optimized version (9 mults less) */ /* ... use this hand optimized version (9 mults less) */
const TReal h = static_cast<TReal>(1.0)/(static_cast<TReal>(1.0) + e); /* optimization by Gottfried Chen */ const TReal h = static_cast<TReal>(1.0)/(static_cast<TReal>(1.0) + e); /* optimization by Gottfried Chen */
const TReal hvx = h * v.x; const TReal hvx = h * v.x;
const TReal hvz = h * v.z; const TReal hvz = h * v.z;
const TReal hvxy = hvx * v.y; const TReal hvxy = hvx * v.y;
const TReal hvxz = hvx * v.z; const TReal hvxz = hvx * v.z;
const TReal hvyz = hvz * v.y; const TReal hvyz = hvz * v.y;
mtx[0][0] = e + hvx * v.x; mtx[0][0] = e + hvx * v.x;
mtx[0][1] = hvxy - v.z; mtx[0][1] = hvxy - v.z;
mtx[0][2] = hvxz + v.y; mtx[0][2] = hvxz + v.y;
mtx[1][0] = hvxy + v.z; mtx[1][0] = hvxy + v.z;
mtx[1][1] = e + h * v.y * v.y; mtx[1][1] = e + h * v.y * v.y;
mtx[1][2] = hvyz - v.x; mtx[1][2] = hvyz - v.x;
mtx[2][0] = hvxz - v.y; mtx[2][0] = hvxz - v.y;
mtx[2][1] = hvyz + v.x; mtx[2][1] = hvyz + v.x;
mtx[2][2] = e + hvz * v.z; mtx[2][2] = e + hvz * v.z;
} }
return mtx; return mtx;
} }
#endif // __cplusplus #endif // __cplusplus
#endif // AI_MATRIX3x3_INL_INC #endif // AI_MATRIX3x3_INL_INC

498
include/assimp/matrix4x4.h
View File

@ -1,249 +1,249 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file matrix4x4.h /** @file matrix4x4.h
* @brief 4x4 matrix structure, including operators when compiling in C++ * @brief 4x4 matrix structure, including operators when compiling in C++
*/ */
#ifndef AI_MATRIX4X4_H_INC #ifndef AI_MATRIX4X4_H_INC
#define AI_MATRIX4X4_H_INC #define AI_MATRIX4X4_H_INC
#include "vector3.h" #include "vector3.h"
#include "./Compiler/pushpack1.h" #include "./Compiler/pushpack1.h"
#ifdef __cplusplus #ifdef __cplusplus
template<typename TReal> class aiMatrix3x3t; template<typename TReal> class aiMatrix3x3t;
template<typename TReal> class aiQuaterniont; template<typename TReal> class aiQuaterniont;
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Represents a row-major 4x4 matrix, use this for homogeneous /** @brief Represents a row-major 4x4 matrix, use this for homogeneous
* coordinates. * coordinates.
* *
* There's much confusion about matrix layouts (column vs. row order). * There's much confusion about matrix layouts (column vs. row order).
* This is *always* a row-major matrix. Not even with the * This is *always* a row-major matrix. Not even with the
* #aiProcess_ConvertToLeftHanded flag, which absolutely does not affect * #aiProcess_ConvertToLeftHanded flag, which absolutely does not affect
* matrix order - it just affects the handedness of the coordinate system * matrix order - it just affects the handedness of the coordinate system
* defined thereby. * defined thereby.
*/ */
template<typename TReal> template<typename TReal>
class aiMatrix4x4t class aiMatrix4x4t
{ {
public: public:
/** set to identity */ /** set to identity */
aiMatrix4x4t (); aiMatrix4x4t ();
/** construction from single values */ /** construction from single values */
aiMatrix4x4t ( TReal _a1, TReal _a2, TReal _a3, TReal _a4, 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);
/** construction from 3x3 matrix, remaining elements are set to identity */ /** construction from 3x3 matrix, remaining elements are set to identity */
explicit aiMatrix4x4t( const aiMatrix3x3t<TReal>& m); explicit aiMatrix4x4t( const aiMatrix3x3t<TReal>& m);
/** construction from position, rotation and scaling components /** construction from position, rotation and scaling components
* @param scaling The scaling for the x,y,z axes * @param scaling The scaling for the x,y,z axes
* @param rotation The rotation as a hamilton quaternion * @param rotation The rotation as a hamilton quaternion
* @param position The position for the x,y,z axes * @param position The position for the x,y,z axes
*/ */
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: public:
// array access operators // array access operators
TReal* operator[] (unsigned int p_iIndex); TReal* operator[] (unsigned int p_iIndex);
const TReal* operator[] (unsigned int p_iIndex) const; const TReal* operator[] (unsigned int p_iIndex) const;
// comparison operators // comparison operators
bool operator== (const aiMatrix4x4t& m) const; bool operator== (const aiMatrix4x4t& m) const;
bool operator!= (const aiMatrix4x4t& m) const; bool operator!= (const aiMatrix4x4t& m) const;
bool Equal(const aiMatrix4x4t& m, TReal epsilon = 1e-6) const; bool Equal(const aiMatrix4x4t& m, TReal epsilon = 1e-6) const;
// matrix multiplication. // matrix multiplication.
aiMatrix4x4t& operator *= (const aiMatrix4x4t& m); aiMatrix4x4t& operator *= (const aiMatrix4x4t& m);
aiMatrix4x4t operator * (const aiMatrix4x4t& m) const; aiMatrix4x4t operator * (const aiMatrix4x4t& m) const;
template <typename TOther> template <typename TOther>
operator aiMatrix4x4t<TOther> () const; operator aiMatrix4x4t<TOther> () const;
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Transpose the matrix */ /** @brief Transpose the matrix */
aiMatrix4x4t& Transpose(); aiMatrix4x4t& Transpose();
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Invert the matrix. /** @brief Invert the matrix.
* If the matrix is not invertible all elements are set to qnan. * If the matrix is not invertible all elements are set to qnan.
* Beware, use (f != f) to check whether a TReal f is qnan. * Beware, use (f != f) to check whether a TReal f is qnan.
*/ */
aiMatrix4x4t& Inverse(); aiMatrix4x4t& Inverse();
TReal Determinant() const; TReal Determinant() const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns true of the matrix is the identity matrix. /** @brief Returns true of the matrix is the identity matrix.
* The check is performed against a not so small epsilon. * The check is performed against a not so small epsilon.
*/ */
inline bool IsIdentity() const; inline bool IsIdentity() const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Decompose a trafo matrix into its original components /** @brief Decompose a trafo matrix into its original components
* @param scaling Receives the output scaling for the x,y,z axes * @param scaling Receives the output scaling for the x,y,z axes
* @param rotation Receives the output rotation as a hamilton * @param rotation Receives the output rotation as a hamilton
* quaternion * quaternion
* @param position Receives the output position for the x,y,z axes * @param position Receives the output position for the x,y,z axes
*/ */
void Decompose (aiVector3t<TReal>& scaling, aiQuaterniont<TReal>& rotation, void Decompose (aiVector3t<TReal>& scaling, aiQuaterniont<TReal>& rotation,
aiVector3t<TReal>& position) const; aiVector3t<TReal>& position) const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Decompose a trafo matrix with no scaling into its /** @brief Decompose a trafo matrix with no scaling into its
* original components * original components
* @param rotation Receives the output rotation as a hamilton * @param rotation Receives the output rotation as a hamilton
* quaternion * quaternion
* @param position Receives the output position for the x,y,z axes * @param position Receives the output position for the x,y,z axes
*/ */
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
* @param y Rotation angle for the y-axis, in radians * @param y Rotation angle for the y-axis, in radians
* @param z Rotation angle for the z-axis, in radians * @param z Rotation angle for the z-axis, in radians
*/ */
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: 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
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix4x4t& RotationX(TReal a, aiMatrix4x4t& out); static aiMatrix4x4t& RotationX(TReal a, aiMatrix4x4t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a rotation matrix for a rotation around the y axis /** @brief Returns a rotation matrix for a rotation around the y axis
* @param a Rotation angle, in radians * @param a Rotation angle, in radians
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix4x4t& RotationY(TReal a, aiMatrix4x4t& out); static aiMatrix4x4t& RotationY(TReal a, aiMatrix4x4t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a rotation matrix for a rotation around the z axis /** @brief Returns a rotation matrix for a rotation around the z axis
* @param a Rotation angle, in radians * @param a Rotation angle, in radians
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix4x4t& RotationZ(TReal a, aiMatrix4x4t& out); static aiMatrix4x4t& RotationZ(TReal a, aiMatrix4x4t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Returns a rotation matrix for a rotation around an arbitrary axis. /** Returns a rotation matrix for a rotation around an arbitrary axis.
* @param a Rotation angle, in radians * @param a Rotation angle, in radians
* @param axis Rotation axis, should be a normalized vector. * @param axis Rotation axis, should be a normalized vector.
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix4x4t& Rotation(TReal a, const aiVector3t<TReal>& axis, static aiMatrix4x4t& Rotation(TReal a, const aiVector3t<TReal>& axis,
aiMatrix4x4t& out); aiMatrix4x4t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a translation matrix /** @brief Returns a translation matrix
* @param v Translation vector * @param v Translation vector
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix4x4t& Translation( const aiVector3t<TReal>& v, aiMatrix4x4t& out); static aiMatrix4x4t& Translation( const aiVector3t<TReal>& v, aiMatrix4x4t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a scaling matrix /** @brief Returns a scaling matrix
* @param v Scaling vector * @param v Scaling vector
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix4x4t& Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t& out); static aiMatrix4x4t& Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief A function for creating a rotation matrix that rotates a /** @brief A function for creating a rotation matrix that rotates a
* vector called "from" into another vector called "to". * vector called "from" into another vector called "to".
* Input : from[3], to[3] which both must be *normalized* non-zero vectors * Input : from[3], to[3] which both must be *normalized* non-zero vectors
* Output: mtx[3][3] -- a 3x3 matrix in colum-major form * Output: mtx[3][3] -- a 3x3 matrix in colum-major form
* Authors: Tomas Möller, John Hughes * Authors: Tomas Möller, John Hughes
* "Efficiently Building a Matrix to Rotate One Vector to Another" * "Efficiently Building a Matrix to Rotate One Vector to Another"
* Journal of Graphics Tools, 4(4):1-4, 1999 * Journal of Graphics Tools, 4(4):1-4, 1999
*/ */
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: 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;
TReal d1, d2, d3, d4; TReal d1, d2, d3, d4;
} PACK_STRUCT; } PACK_STRUCT;
typedef aiMatrix4x4t<float> aiMatrix4x4; typedef aiMatrix4x4t<float> aiMatrix4x4;
#else #else
struct aiMatrix4x4 { struct aiMatrix4x4 {
float a1, a2, a3, a4; float a1, a2, a3, a4;
float b1, b2, b3, b4; float b1, b2, b3, b4;
float c1, c2, c3, c4; float c1, c2, c3, c4;
float d1, d2, d3, d4; float d1, d2, d3, d4;
}; };
#endif // __cplusplus #endif // __cplusplus
#include "./Compiler/poppack1.h" #include "./Compiler/poppack1.h"
#endif // AI_MATRIX4X4_H_INC #endif // AI_MATRIX4X4_H_INC

1070
include/assimp/matrix4x4.inl
View File

File diff suppressed because it is too large Load Diff

1478
include/assimp/mesh.h
View File

File diff suppressed because it is too large Load Diff

1266
include/assimp/postprocess.h
View File

File diff suppressed because it is too large Load Diff

252
include/assimp/quaternion.h
View File

@ -1,126 +1,126 @@
/* /*
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
---------------------------------------------------------------------- ----------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the with or without modification, are permitted provided that the
following conditions are met: following conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
/** @file quaternion.h /** @file quaternion.h
* @brief Quaternion structure, including operators when compiling in C++ * @brief Quaternion structure, including operators when compiling in C++
*/ */
#ifndef AI_QUATERNION_H_INC #ifndef AI_QUATERNION_H_INC
#define AI_QUATERNION_H_INC #define AI_QUATERNION_H_INC
#ifdef __cplusplus #ifdef __cplusplus
template <typename TReal> class aiVector3t; template <typename TReal> class aiVector3t;
template <typename TReal> class aiMatrix3x3t; template <typename TReal> class aiMatrix3x3t;
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Represents a quaternion in a 4D vector. */ /** Represents a quaternion in a 4D vector. */
template <typename TReal> template <typename TReal>
class aiQuaterniont class aiQuaterniont
{ {
public: public:
aiQuaterniont() : w(1.0), x(), y(), z() {} aiQuaterniont() : w(1.0), x(), y(), z() {}
aiQuaterniont(TReal pw, TReal px, TReal py, TReal pz) aiQuaterniont(TReal pw, TReal px, TReal py, TReal pz)
: w(pw), x(px), y(py), z(pz) {} : w(pw), x(px), y(py), z(pz) {}
/** Construct from rotation matrix. Result is undefined if the matrix is not orthonormal. */ /** Construct from rotation matrix. Result is undefined if the matrix is not orthonormal. */
aiQuaterniont( const aiMatrix3x3t<TReal>& pRotMatrix); aiQuaterniont( const aiMatrix3x3t<TReal>& pRotMatrix);
/** Construct from euler angles */ /** Construct from euler angles */
aiQuaterniont( TReal rotx, TReal roty, TReal rotz); aiQuaterniont( TReal rotx, TReal roty, TReal rotz);
/** Construct from an axis-angle pair */ /** Construct from an axis-angle pair */
aiQuaterniont( aiVector3t<TReal> axis, TReal angle); aiQuaterniont( aiVector3t<TReal> axis, TReal angle);
/** Construct from a normalized quaternion stored in a vec3 */ /** Construct from a normalized quaternion stored in a vec3 */
aiQuaterniont( aiVector3t<TReal> normalized); aiQuaterniont( aiVector3t<TReal> normalized);
/** Returns a matrix representation of the quaternion */ /** Returns a matrix representation of the quaternion */
aiMatrix3x3t<TReal> GetMatrix() const; aiMatrix3x3t<TReal> GetMatrix() const;
public: public:
bool operator== (const aiQuaterniont& o) const; bool operator== (const aiQuaterniont& o) const;
bool operator!= (const aiQuaterniont& o) const; bool operator!= (const aiQuaterniont& o) const;
bool Equal(const aiQuaterniont& o, TReal epsilon = 1e-6) const; bool Equal(const aiQuaterniont& o, TReal epsilon = 1e-6) const;
public: public:
/** Normalize the quaternion */ /** Normalize the quaternion */
aiQuaterniont& Normalize(); aiQuaterniont& Normalize();
/** Compute quaternion conjugate */ /** Compute quaternion conjugate */
aiQuaterniont& Conjugate (); aiQuaterniont& Conjugate ();
/** Rotate a point by this quaternion */ /** Rotate a point by this quaternion */
aiVector3t<TReal> Rotate (const aiVector3t<TReal>& in); aiVector3t<TReal> Rotate (const aiVector3t<TReal>& in);
/** Multiply two quaternions */ /** Multiply two quaternions */
aiQuaterniont operator* (const aiQuaterniont& two) const; aiQuaterniont operator* (const aiQuaterniont& two) const;
public: public:
/** Performs a spherical interpolation between two quaternions and writes the result into the third. /** Performs a spherical interpolation between two quaternions and writes the result into the third.
* @param pOut Target object to received the interpolated rotation. * @param pOut Target object to received the interpolated rotation.
* @param pStart Start rotation of the interpolation at factor == 0. * @param pStart Start rotation of the interpolation at factor == 0.
* @param pEnd End rotation, factor == 1. * @param pEnd End rotation, factor == 1.
* @param pFactor Interpolation factor between 0 and 1. Values outside of this range yield undefined results. * @param pFactor Interpolation factor between 0 and 1. Values outside of this range yield undefined results.
*/ */
static void Interpolate( aiQuaterniont& pOut, const aiQuaterniont& pStart, static void Interpolate( aiQuaterniont& pOut, const aiQuaterniont& pStart,
const aiQuaterniont& pEnd, TReal pFactor); const aiQuaterniont& pEnd, TReal pFactor);
public: public:
//! w,x,y,z components of the quaternion //! w,x,y,z components of the quaternion
TReal w, x, y, z; TReal w, x, y, z;
} ; } ;
typedef aiQuaterniont<float> aiQuaternion; typedef aiQuaterniont<float> aiQuaternion;
#else #else
struct aiQuaternion { struct aiQuaternion {
float w, x, y, z; float w, x, y, z;
}; };
#endif #endif
#endif // AI_QUATERNION_H_INC #endif // AI_QUATERNION_H_INC

566
include/assimp/quaternion.inl
View File

@ -1,283 +1,283 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file quaternion.inl /** @file quaternion.inl
* @brief Inline implementation of aiQuaterniont<TReal> operators * @brief Inline implementation of aiQuaterniont<TReal> operators
*/ */
#ifndef AI_QUATERNION_INL_INC #ifndef AI_QUATERNION_INL_INC
#define AI_QUATERNION_INL_INC #define AI_QUATERNION_INL_INC
#ifdef __cplusplus #ifdef __cplusplus
#include "quaternion.h" #include "quaternion.h"
#include <cmath> #include <cmath>
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
bool aiQuaterniont<TReal>::operator== (const aiQuaterniont& o) const bool aiQuaterniont<TReal>::operator== (const aiQuaterniont& o) const
{ {
return x == o.x && y == o.y && z == o.z && w == o.w; return x == o.x && y == o.y && z == o.z && w == o.w;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
bool aiQuaterniont<TReal>::operator!= (const aiQuaterniont& o) const bool aiQuaterniont<TReal>::operator!= (const aiQuaterniont& o) const
{ {
return !(*this == o); return !(*this == o);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
inline bool aiQuaterniont<TReal>::Equal(const aiQuaterniont& o, TReal epsilon) const { inline bool aiQuaterniont<TReal>::Equal(const aiQuaterniont& o, TReal epsilon) const {
return return
std::abs(x - o.x) <= epsilon && std::abs(x - o.x) <= epsilon &&
std::abs(y - o.y) <= epsilon && std::abs(y - o.y) <= epsilon &&
std::abs(z - o.z) <= epsilon && std::abs(z - o.z) <= epsilon &&
std::abs(w - o.w) <= epsilon; std::abs(w - o.w) <= epsilon;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Constructs a quaternion from a rotation matrix // Constructs a quaternion from a rotation matrix
template<typename TReal> template<typename TReal>
inline aiQuaterniont<TReal>::aiQuaterniont( const aiMatrix3x3t<TReal> &pRotMatrix) inline aiQuaterniont<TReal>::aiQuaterniont( const aiMatrix3x3t<TReal> &pRotMatrix)
{ {
TReal t = pRotMatrix.a1 + pRotMatrix.b2 + pRotMatrix.c3; TReal t = pRotMatrix.a1 + pRotMatrix.b2 + pRotMatrix.c3;
// large enough // large enough
if( t > static_cast<TReal>(0)) if( t > static_cast<TReal>(0))
{ {
TReal s = std::sqrt(1 + t) * static_cast<TReal>(2.0); TReal s = std::sqrt(1 + t) * static_cast<TReal>(2.0);
x = (pRotMatrix.c2 - pRotMatrix.b3) / s; x = (pRotMatrix.c2 - pRotMatrix.b3) / s;
y = (pRotMatrix.a3 - pRotMatrix.c1) / s; y = (pRotMatrix.a3 - pRotMatrix.c1) / s;
z = (pRotMatrix.b1 - pRotMatrix.a2) / s; z = (pRotMatrix.b1 - pRotMatrix.a2) / s;
w = static_cast<TReal>(0.25) * s; w = static_cast<TReal>(0.25) * s;
} // else we have to check several cases } // else we have to check several cases
else if( pRotMatrix.a1 > pRotMatrix.b2 && pRotMatrix.a1 > pRotMatrix.c3 ) else if( pRotMatrix.a1 > pRotMatrix.b2 && pRotMatrix.a1 > pRotMatrix.c3 )
{ {
// Column 0: // Column 0:
TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.a1 - pRotMatrix.b2 - pRotMatrix.c3) * static_cast<TReal>(2.0); TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.a1 - pRotMatrix.b2 - pRotMatrix.c3) * static_cast<TReal>(2.0);
x = static_cast<TReal>(0.25) * s; x = static_cast<TReal>(0.25) * s;
y = (pRotMatrix.b1 + pRotMatrix.a2) / s; y = (pRotMatrix.b1 + pRotMatrix.a2) / s;
z = (pRotMatrix.a3 + pRotMatrix.c1) / s; z = (pRotMatrix.a3 + pRotMatrix.c1) / s;
w = (pRotMatrix.c2 - pRotMatrix.b3) / s; w = (pRotMatrix.c2 - pRotMatrix.b3) / s;
} }
else if( pRotMatrix.b2 > pRotMatrix.c3) else if( pRotMatrix.b2 > pRotMatrix.c3)
{ {
// Column 1: // Column 1:
TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.b2 - pRotMatrix.a1 - pRotMatrix.c3) * static_cast<TReal>(2.0); TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.b2 - pRotMatrix.a1 - pRotMatrix.c3) * static_cast<TReal>(2.0);
x = (pRotMatrix.b1 + pRotMatrix.a2) / s; x = (pRotMatrix.b1 + pRotMatrix.a2) / s;
y = static_cast<TReal>(0.25) * s; y = static_cast<TReal>(0.25) * s;
z = (pRotMatrix.c2 + pRotMatrix.b3) / s; z = (pRotMatrix.c2 + pRotMatrix.b3) / s;
w = (pRotMatrix.a3 - pRotMatrix.c1) / s; w = (pRotMatrix.a3 - pRotMatrix.c1) / s;
} else } else
{ {
// Column 2: // Column 2:
TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.c3 - pRotMatrix.a1 - pRotMatrix.b2) * static_cast<TReal>(2.0); TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.c3 - pRotMatrix.a1 - pRotMatrix.b2) * static_cast<TReal>(2.0);
x = (pRotMatrix.a3 + pRotMatrix.c1) / s; x = (pRotMatrix.a3 + pRotMatrix.c1) / s;
y = (pRotMatrix.c2 + pRotMatrix.b3) / s; y = (pRotMatrix.c2 + pRotMatrix.b3) / s;
z = static_cast<TReal>(0.25) * s; z = static_cast<TReal>(0.25) * s;
w = (pRotMatrix.b1 - pRotMatrix.a2) / s; w = (pRotMatrix.b1 - pRotMatrix.a2) / s;
} }
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Construction from euler angles // Construction from euler angles
template<typename TReal> template<typename TReal>
inline aiQuaterniont<TReal>::aiQuaterniont( TReal fPitch, TReal fYaw, TReal fRoll ) inline aiQuaterniont<TReal>::aiQuaterniont( TReal fPitch, TReal fYaw, TReal fRoll )
{ {
const TReal fSinPitch(std::sin(fPitch*static_cast<TReal>(0.5))); const TReal fSinPitch(std::sin(fPitch*static_cast<TReal>(0.5)));
const TReal fCosPitch(std::cos(fPitch*static_cast<TReal>(0.5))); const TReal fCosPitch(std::cos(fPitch*static_cast<TReal>(0.5)));
const TReal fSinYaw(std::sin(fYaw*static_cast<TReal>(0.5))); const TReal fSinYaw(std::sin(fYaw*static_cast<TReal>(0.5)));
const TReal fCosYaw(std::cos(fYaw*static_cast<TReal>(0.5))); const TReal fCosYaw(std::cos(fYaw*static_cast<TReal>(0.5)));
const TReal fSinRoll(std::sin(fRoll*static_cast<TReal>(0.5))); const TReal fSinRoll(std::sin(fRoll*static_cast<TReal>(0.5)));
const TReal fCosRoll(std::cos(fRoll*static_cast<TReal>(0.5))); const TReal fCosRoll(std::cos(fRoll*static_cast<TReal>(0.5)));
const TReal fCosPitchCosYaw(fCosPitch*fCosYaw); const TReal fCosPitchCosYaw(fCosPitch*fCosYaw);
const TReal fSinPitchSinYaw(fSinPitch*fSinYaw); const TReal fSinPitchSinYaw(fSinPitch*fSinYaw);
x = fSinRoll * fCosPitchCosYaw - fCosRoll * fSinPitchSinYaw; x = fSinRoll * fCosPitchCosYaw - fCosRoll * fSinPitchSinYaw;
y = fCosRoll * fSinPitch * fCosYaw + fSinRoll * fCosPitch * fSinYaw; y = fCosRoll * fSinPitch * fCosYaw + fSinRoll * fCosPitch * fSinYaw;
z = fCosRoll * fCosPitch * fSinYaw - fSinRoll * fSinPitch * fCosYaw; z = fCosRoll * fCosPitch * fSinYaw - fSinRoll * fSinPitch * fCosYaw;
w = fCosRoll * fCosPitchCosYaw + fSinRoll * fSinPitchSinYaw; w = fCosRoll * fCosPitchCosYaw + fSinRoll * fSinPitchSinYaw;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Returns a matrix representation of the quaternion // Returns a matrix representation of the quaternion
template<typename TReal> template<typename TReal>
inline aiMatrix3x3t<TReal> aiQuaterniont<TReal>::GetMatrix() const inline aiMatrix3x3t<TReal> aiQuaterniont<TReal>::GetMatrix() const
{ {
aiMatrix3x3t<TReal> resMatrix; aiMatrix3x3t<TReal> resMatrix;
resMatrix.a1 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (y * y + z * z); resMatrix.a1 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (y * y + z * z);
resMatrix.a2 = static_cast<TReal>(2.0) * (x * y - z * w); resMatrix.a2 = static_cast<TReal>(2.0) * (x * y - z * w);
resMatrix.a3 = static_cast<TReal>(2.0) * (x * z + y * w); resMatrix.a3 = static_cast<TReal>(2.0) * (x * z + y * w);
resMatrix.b1 = static_cast<TReal>(2.0) * (x * y + z * w); resMatrix.b1 = static_cast<TReal>(2.0) * (x * y + z * w);
resMatrix.b2 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (x * x + z * z); resMatrix.b2 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (x * x + z * z);
resMatrix.b3 = static_cast<TReal>(2.0) * (y * z - x * w); resMatrix.b3 = static_cast<TReal>(2.0) * (y * z - x * w);
resMatrix.c1 = static_cast<TReal>(2.0) * (x * z - y * w); resMatrix.c1 = static_cast<TReal>(2.0) * (x * z - y * w);
resMatrix.c2 = static_cast<TReal>(2.0) * (y * z + x * w); resMatrix.c2 = static_cast<TReal>(2.0) * (y * z + x * w);
resMatrix.c3 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (x * x + y * y); resMatrix.c3 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (x * x + y * y);
return resMatrix; return resMatrix;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Construction from an axis-angle pair // Construction from an axis-angle pair
template<typename TReal> template<typename TReal>
inline aiQuaterniont<TReal>::aiQuaterniont( aiVector3t<TReal> axis, TReal angle) inline aiQuaterniont<TReal>::aiQuaterniont( aiVector3t<TReal> axis, TReal angle)
{ {
axis.Normalize(); axis.Normalize();
const TReal sin_a = std::sin( angle / 2 ); const TReal sin_a = std::sin( angle / 2 );
const TReal cos_a = std::cos( angle / 2 ); const TReal cos_a = std::cos( angle / 2 );
x = axis.x * sin_a; x = axis.x * sin_a;
y = axis.y * sin_a; y = axis.y * sin_a;
z = axis.z * sin_a; z = axis.z * sin_a;
w = cos_a; w = cos_a;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Construction from am existing, normalized quaternion // Construction from am existing, normalized quaternion
template<typename TReal> template<typename TReal>
inline aiQuaterniont<TReal>::aiQuaterniont( aiVector3t<TReal> normalized) inline aiQuaterniont<TReal>::aiQuaterniont( aiVector3t<TReal> normalized)
{ {
x = normalized.x; x = normalized.x;
y = normalized.y; y = normalized.y;
z = normalized.z; z = normalized.z;
const TReal t = static_cast<TReal>(1.0) - (x*x) - (y*y) - (z*z); const TReal t = static_cast<TReal>(1.0) - (x*x) - (y*y) - (z*z);
if (t < static_cast<TReal>(0.0)) { if (t < static_cast<TReal>(0.0)) {
w = static_cast<TReal>(0.0); w = static_cast<TReal>(0.0);
} }
else w = std::sqrt (t); else w = std::sqrt (t);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Performs a spherical interpolation between two quaternions // Performs a spherical interpolation between two quaternions
// Implementation adopted from the gmtl project. All others I found on the net fail in some cases. // Implementation adopted from the gmtl project. All others I found on the net fail in some cases.
// Congrats, gmtl! // Congrats, gmtl!
template<typename TReal> template<typename TReal>
inline void aiQuaterniont<TReal>::Interpolate( aiQuaterniont& pOut, const aiQuaterniont& pStart, const aiQuaterniont& pEnd, TReal pFactor) inline void aiQuaterniont<TReal>::Interpolate( aiQuaterniont& pOut, const aiQuaterniont& pStart, const aiQuaterniont& pEnd, TReal pFactor)
{ {
// calc cosine theta // calc cosine theta
TReal cosom = pStart.x * pEnd.x + pStart.y * pEnd.y + pStart.z * pEnd.z + pStart.w * pEnd.w; TReal cosom = pStart.x * pEnd.x + pStart.y * pEnd.y + pStart.z * pEnd.z + pStart.w * pEnd.w;
// adjust signs (if necessary) // adjust signs (if necessary)
aiQuaterniont end = pEnd; aiQuaterniont end = pEnd;
if( cosom < static_cast<TReal>(0.0)) if( cosom < static_cast<TReal>(0.0))
{ {
cosom = -cosom; cosom = -cosom;
end.x = -end.x; // Reverse all signs end.x = -end.x; // Reverse all signs
end.y = -end.y; end.y = -end.y;
end.z = -end.z; end.z = -end.z;
end.w = -end.w; end.w = -end.w;
} }
// Calculate coefficients // Calculate coefficients
TReal sclp, sclq; TReal sclp, sclq;
if( (static_cast<TReal>(1.0) - cosom) > static_cast<TReal>(0.0001)) // 0.0001 -> some epsillon if( (static_cast<TReal>(1.0) - cosom) > static_cast<TReal>(0.0001)) // 0.0001 -> some epsillon
{ {
// Standard case (slerp) // Standard case (slerp)
TReal omega, sinom; TReal omega, sinom;
omega = std::acos( cosom); // extract theta from dot product's cos theta omega = std::acos( cosom); // extract theta from dot product's cos theta
sinom = std::sin( omega); sinom = std::sin( omega);
sclp = std::sin( (static_cast<TReal>(1.0) - pFactor) * omega) / sinom; sclp = std::sin( (static_cast<TReal>(1.0) - pFactor) * omega) / sinom;
sclq = std::sin( pFactor * omega) / sinom; sclq = std::sin( pFactor * omega) / sinom;
} else } else
{ {
// Very close, do linear interp (because it's faster) // Very close, do linear interp (because it's faster)
sclp = static_cast<TReal>(1.0) - pFactor; sclp = static_cast<TReal>(1.0) - pFactor;
sclq = pFactor; sclq = pFactor;
} }
pOut.x = sclp * pStart.x + sclq * end.x; pOut.x = sclp * pStart.x + sclq * end.x;
pOut.y = sclp * pStart.y + sclq * end.y; pOut.y = sclp * pStart.y + sclq * end.y;
pOut.z = sclp * pStart.z + sclq * end.z; pOut.z = sclp * pStart.z + sclq * end.z;
pOut.w = sclp * pStart.w + sclq * end.w; pOut.w = sclp * pStart.w + sclq * end.w;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
inline aiQuaterniont<TReal>& aiQuaterniont<TReal>::Normalize() inline aiQuaterniont<TReal>& aiQuaterniont<TReal>::Normalize()
{ {
// compute the magnitude and divide through it // compute the magnitude and divide through it
const TReal mag = std::sqrt(x*x + y*y + z*z + w*w); const TReal mag = std::sqrt(x*x + y*y + z*z + w*w);
if (mag) if (mag)
{ {
const TReal invMag = static_cast<TReal>(1.0)/mag; const TReal invMag = static_cast<TReal>(1.0)/mag;
x *= invMag; x *= invMag;
y *= invMag; y *= invMag;
z *= invMag; z *= invMag;
w *= invMag; w *= invMag;
} }
return *this; return *this;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
inline aiQuaterniont<TReal> aiQuaterniont<TReal>::operator* (const aiQuaterniont& t) const inline aiQuaterniont<TReal> aiQuaterniont<TReal>::operator* (const aiQuaterniont& t) const
{ {
return aiQuaterniont(w*t.w - x*t.x - y*t.y - z*t.z, return aiQuaterniont(w*t.w - x*t.x - y*t.y - z*t.z,
w*t.x + x*t.w + y*t.z - z*t.y, w*t.x + x*t.w + y*t.z - z*t.y,
w*t.y + y*t.w + z*t.x - x*t.z, w*t.y + y*t.w + z*t.x - x*t.z,
w*t.z + z*t.w + x*t.y - y*t.x); w*t.z + z*t.w + x*t.y - y*t.x);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
inline aiQuaterniont<TReal>& aiQuaterniont<TReal>::Conjugate () inline aiQuaterniont<TReal>& aiQuaterniont<TReal>::Conjugate ()
{ {
x = -x; x = -x;
y = -y; y = -y;
z = -z; z = -z;
return *this; return *this;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
inline aiVector3t<TReal> aiQuaterniont<TReal>::Rotate (const aiVector3t<TReal>& v) inline aiVector3t<TReal> aiQuaterniont<TReal>::Rotate (const aiVector3t<TReal>& v)
{ {
aiQuaterniont q2(0.f,v.x,v.y,v.z), q = *this, qinv = q; aiQuaterniont q2(0.f,v.x,v.y,v.z), q = *this, qinv = q;
qinv.Conjugate(); qinv.Conjugate();
q = q*q2*qinv; q = q*q2*qinv;
return aiVector3t<TReal>(q.x,q.y,q.z); return aiVector3t<TReal>(q.x,q.y,q.z);
} }
#endif #endif
#endif #endif

852
include/assimp/scene.h
View File

@ -1,426 +1,426 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file scene.h /** @file scene.h
* @brief Defines the data structures in which the imported scene is returned. * @brief Defines the data structures in which the imported scene is returned.
*/ */
#ifndef __AI_SCENE_H_INC__ #ifndef __AI_SCENE_H_INC__
#define __AI_SCENE_H_INC__ #define __AI_SCENE_H_INC__
#include "types.h" #include "types.h"
#include "texture.h" #include "texture.h"
#include "mesh.h" #include "mesh.h"
#include "light.h" #include "light.h"
#include "camera.h" #include "camera.h"
#include "material.h" #include "material.h"
#include "anim.h" #include "anim.h"
#include "metadata.h" #include "metadata.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
/** A node in the imported hierarchy. /** A node in the imported hierarchy.
* *
* Each node has name, a parent node (except for the root node), * Each node has name, a parent node (except for the root node),
* a transformation relative to its parent and possibly several child nodes. * a transformation relative to its parent and possibly several child nodes.
* Simple file formats don't support hierarchical structures - for these formats * Simple file formats don't support hierarchical structures - for these formats
* the imported scene does consist of only a single root node without children. * the imported scene does consist of only a single root node without children.
*/ */
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
struct aiNode struct aiNode
{ {
/** The name of the node. /** The name of the node.
* *
* The name might be empty (length of zero) but all nodes which * The name might be empty (length of zero) but all nodes which
* need to be referenced by either bones or animations are named. * need to be referenced by either bones or animations are named.
* Multiple nodes may have the same name, except for nodes which are referenced * Multiple nodes may have the same name, except for nodes which are referenced
* by bones (see #aiBone and #aiMesh::mBones). Their names *must* be unique. * by bones (see #aiBone and #aiMesh::mBones). Their names *must* be unique.
* *
* Cameras and lights reference a specific node by name - if there * Cameras and lights reference a specific node by name - if there
* are multiple nodes with this name, they are assigned to each of them. * are multiple nodes with this name, they are assigned to each of them.
* <br> * <br>
* There are no limitations with regard to the characters contained in * There are no limitations with regard to the characters contained in
* the name string as it is usually taken directly from the source file. * the name string as it is usually taken directly from the source file.
* *
* Implementations should be able to handle tokens such as whitespace, tabs, * Implementations should be able to handle tokens such as whitespace, tabs,
* line feeds, quotation marks, ampersands etc. * line feeds, quotation marks, ampersands etc.
* *
* Sometimes assimp introduces new nodes not present in the source file * Sometimes assimp introduces new nodes not present in the source file
* into the hierarchy (usually out of necessity because sometimes the * into the hierarchy (usually out of necessity because sometimes the
* source hierarchy format is simply not compatible). Their names are * source hierarchy format is simply not compatible). Their names are
* surrounded by @verbatim <> @endverbatim e.g. * surrounded by @verbatim <> @endverbatim e.g.
* @verbatim<DummyRootNode> @endverbatim. * @verbatim<DummyRootNode> @endverbatim.
*/ */
C_STRUCT aiString mName; C_STRUCT aiString mName;
/** The transformation relative to the node's parent. */ /** The transformation relative to the node's parent. */
C_STRUCT aiMatrix4x4 mTransformation; C_STRUCT aiMatrix4x4 mTransformation;
/** Parent node. NULL if this node is the root node. */ /** Parent node. NULL if this node is the root node. */
C_STRUCT aiNode* mParent; C_STRUCT aiNode* mParent;
/** The number of child nodes of this node. */ /** The number of child nodes of this node. */
unsigned int mNumChildren; unsigned int mNumChildren;
/** The child nodes of this node. NULL if mNumChildren is 0. */ /** The child nodes of this node. NULL if mNumChildren is 0. */
C_STRUCT aiNode** mChildren; C_STRUCT aiNode** mChildren;
/** The number of meshes of this node. */ /** The number of meshes of this node. */
unsigned int mNumMeshes; unsigned int mNumMeshes;
/** The meshes of this node. Each entry is an index into the mesh */ /** The meshes of this node. Each entry is an index into the mesh */
unsigned int* mMeshes; unsigned int* mMeshes;
/** Metadata associated with this node or NULL if there is no metadata. /** Metadata associated with this node or NULL if there is no metadata.
* Whether any metadata is generated depends on the source file format. See the * Whether any metadata is generated depends on the source file format. See the
* @link importer_notes @endlink page for more information on every source file * @link importer_notes @endlink page for more information on every source file
* format. Importers that don't document any metadata don't write any. * format. Importers that don't document any metadata don't write any.
*/ */
C_STRUCT aiMetadata* mMetaData; C_STRUCT aiMetadata* mMetaData;
#ifdef __cplusplus #ifdef __cplusplus
/** Constructor */ /** Constructor */
aiNode() aiNode()
// set all members to zero by default // set all members to zero by default
: mName("") : mName("")
, mParent(NULL) , mParent(NULL)
, mNumChildren(0) , mNumChildren(0)
, mChildren(NULL) , mChildren(NULL)
, mNumMeshes(0) , mNumMeshes(0)
, mMeshes(NULL) , mMeshes(NULL)
, mMetaData(NULL) , mMetaData(NULL)
{ {
} }
/** Construction from a specific name */ /** Construction from a specific name */
aiNode(const std::string& name) aiNode(const std::string& name)
// set all members to zero by default // set all members to zero by default
: mName(name) : mName(name)
, mParent(NULL) , mParent(NULL)
, mNumChildren(0) , mNumChildren(0)
, mChildren(NULL) , mChildren(NULL)
, mNumMeshes(0) , mNumMeshes(0)
, mMeshes(NULL) , mMeshes(NULL)
, mMetaData(NULL) , mMetaData(NULL)
{ {
} }
/** Destructor */ /** Destructor */
~aiNode() ~aiNode()
{ {
// delete all children recursively // delete all children recursively
// to make sure we won't crash if the data is invalid ... // to make sure we won't crash if the data is invalid ...
if (mChildren && mNumChildren) if (mChildren && mNumChildren)
{ {
for( unsigned int a = 0; a < mNumChildren; a++) for( unsigned int a = 0; a < mNumChildren; a++)
delete mChildren[a]; delete mChildren[a];
} }
delete [] mChildren; delete [] mChildren;
delete [] mMeshes; delete [] mMeshes;
delete mMetaData; delete mMetaData;
} }
/** Searches for a node with a specific name, beginning at this /** Searches for a node with a specific name, beginning at this
* nodes. Normally you will call this method on the root node * nodes. Normally you will call this method on the root node
* of the scene. * of the scene.
* *
* @param name Name to search for * @param name Name to search for
* @return NULL or a valid Node if the search was successful. * @return NULL or a valid Node if the search was successful.
*/ */
inline const aiNode* FindNode(const aiString& name) const inline const aiNode* FindNode(const aiString& name) const
{ {
return FindNode(name.data); return FindNode(name.data);
} }
inline aiNode* FindNode(const aiString& name) inline aiNode* FindNode(const aiString& name)
{ {
return FindNode(name.data); return FindNode(name.data);
} }
inline const aiNode* FindNode(const char* name) const inline const aiNode* FindNode(const char* name) const
{ {
if (!::strcmp( mName.data,name))return this; if (!::strcmp( mName.data,name))return this;
for (unsigned int i = 0; i < mNumChildren;++i) for (unsigned int i = 0; i < mNumChildren;++i)
{ {
const aiNode* const p = mChildren[i]->FindNode(name); const aiNode* const p = mChildren[i]->FindNode(name);
if (p) { if (p) {
return p; return p;
} }
} }
// there is definitely no sub-node with this name // there is definitely no sub-node with this name
return NULL; return NULL;
} }
inline aiNode* FindNode(const char* name) inline aiNode* FindNode(const char* name)
{ {
if (!::strcmp( mName.data,name))return this; if (!::strcmp( mName.data,name))return this;
for (unsigned int i = 0; i < mNumChildren;++i) for (unsigned int i = 0; i < mNumChildren;++i)
{ {
aiNode* const p = mChildren[i]->FindNode(name); aiNode* const p = mChildren[i]->FindNode(name);
if (p) { if (p) {
return p; return p;
} }
} }
// there is definitely no sub-node with this name // there is definitely no sub-node with this name
return NULL; return NULL;
} }
#endif // __cplusplus #endif // __cplusplus
}; };
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
/** /**
* Specifies that the scene data structure that was imported is not complete. * Specifies that the scene data structure that was imported is not complete.
* This flag bypasses some internal validations and allows the import * This flag bypasses some internal validations and allows the import
* of animation skeletons, material libraries or camera animation paths * of animation skeletons, material libraries or camera animation paths
* using Assimp. Most applications won't support such data. * using Assimp. Most applications won't support such data.
*/ */
#define AI_SCENE_FLAGS_INCOMPLETE 0x1 #define AI_SCENE_FLAGS_INCOMPLETE 0x1
/** /**
* This flag is set by the validation postprocess-step (aiPostProcess_ValidateDS) * This flag is set by the validation postprocess-step (aiPostProcess_ValidateDS)
* if the validation is successful. In a validated scene you can be sure that * if the validation is successful. In a validated scene you can be sure that
* any cross references in the data structure (e.g. vertex indices) are valid. * any cross references in the data structure (e.g. vertex indices) are valid.
*/ */
#define AI_SCENE_FLAGS_VALIDATED 0x2 #define AI_SCENE_FLAGS_VALIDATED 0x2
/** /**
* This flag is set by the validation postprocess-step (aiPostProcess_ValidateDS) * This flag is set by the validation postprocess-step (aiPostProcess_ValidateDS)
* if the validation is successful but some issues have been found. * if the validation is successful but some issues have been found.
* This can for example mean that a texture that does not exist is referenced * This can for example mean that a texture that does not exist is referenced
* by a material or that the bone weights for a vertex don't sum to 1.0 ... . * by a material or that the bone weights for a vertex don't sum to 1.0 ... .
* In most cases you should still be able to use the import. This flag could * In most cases you should still be able to use the import. This flag could
* be useful for applications which don't capture Assimp's log output. * be useful for applications which don't capture Assimp's log output.
*/ */
#define AI_SCENE_FLAGS_VALIDATION_WARNING 0x4 #define AI_SCENE_FLAGS_VALIDATION_WARNING 0x4
/** /**
* This flag is currently only set by the aiProcess_JoinIdenticalVertices step. * This flag is currently only set by the aiProcess_JoinIdenticalVertices step.
* It indicates that the vertices of the output meshes aren't in the internal * It indicates that the vertices of the output meshes aren't in the internal
* verbose format anymore. In the verbose format all vertices are unique, * verbose format anymore. In the verbose format all vertices are unique,
* no vertex is ever referenced by more than one face. * no vertex is ever referenced by more than one face.
*/ */
#define AI_SCENE_FLAGS_NON_VERBOSE_FORMAT 0x8 #define AI_SCENE_FLAGS_NON_VERBOSE_FORMAT 0x8
/** /**
* Denotes pure height-map terrain data. Pure terrains usually consist of quads, * Denotes pure height-map terrain data. Pure terrains usually consist of quads,
* sometimes triangles, in a regular grid. The x,y coordinates of all vertex * sometimes triangles, in a regular grid. The x,y coordinates of all vertex
* positions refer to the x,y coordinates on the terrain height map, the z-axis * positions refer to the x,y coordinates on the terrain height map, the z-axis
* stores the elevation at a specific point. * stores the elevation at a specific point.
* *
* TER (Terragen) and HMP (3D Game Studio) are height map formats. * TER (Terragen) and HMP (3D Game Studio) are height map formats.
* @note Assimp is probably not the best choice for loading *huge* terrains - * @note Assimp is probably not the best choice for loading *huge* terrains -
* fully triangulated data takes extremely much free store and should be avoided * fully triangulated data takes extremely much free store and should be avoided
* as long as possible (typically you'll do the triangulation when you actually * as long as possible (typically you'll do the triangulation when you actually
* need to render it). * need to render it).
*/ */
#define AI_SCENE_FLAGS_TERRAIN 0x10 #define AI_SCENE_FLAGS_TERRAIN 0x10
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
/** The root structure of the imported data. /** The root structure of the imported data.
* *
* Everything that was imported from the given file can be accessed from here. * Everything that was imported from the given file can be accessed from here.
* Objects of this class are generally maintained and owned by Assimp, not * Objects of this class are generally maintained and owned by Assimp, not
* by the caller. You shouldn't want to instance it, nor should you ever try to * by the caller. You shouldn't want to instance it, nor should you ever try to
* delete a given scene on your own. * delete a given scene on your own.
*/ */
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
struct aiScene struct aiScene
{ {
/** Any combination of the AI_SCENE_FLAGS_XXX flags. By default /** Any combination of the AI_SCENE_FLAGS_XXX flags. By default
* this value is 0, no flags are set. Most applications will * this value is 0, no flags are set. Most applications will
* want to reject all scenes with the AI_SCENE_FLAGS_INCOMPLETE * want to reject all scenes with the AI_SCENE_FLAGS_INCOMPLETE
* bit set. * bit set.
*/ */
unsigned int mFlags; unsigned int mFlags;
/** The root node of the hierarchy. /** The root node of the hierarchy.
* *
* There will always be at least the root node if the import * There will always be at least the root node if the import
* was successful (and no special flags have been set). * was successful (and no special flags have been set).
* Presence of further nodes depends on the format and content * Presence of further nodes depends on the format and content
* of the imported file. * of the imported file.
*/ */
C_STRUCT aiNode* mRootNode; C_STRUCT aiNode* mRootNode;
/** The number of meshes in the scene. */ /** The number of meshes in the scene. */
unsigned int mNumMeshes; unsigned int mNumMeshes;
/** The array of meshes. /** The array of meshes.
* *
* Use the indices given in the aiNode structure to access * Use the indices given in the aiNode structure to access
* this array. The array is mNumMeshes in size. If the * this array. The array is mNumMeshes in size. If the
* AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always * AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always
* be at least ONE material. * be at least ONE material.
*/ */
C_STRUCT aiMesh** mMeshes; C_STRUCT aiMesh** mMeshes;
/** The number of materials in the scene. */ /** The number of materials in the scene. */
unsigned int mNumMaterials; unsigned int mNumMaterials;
/** The array of materials. /** The array of materials.
* *
* Use the index given in each aiMesh structure to access this * Use the index given in each aiMesh structure to access this
* array. The array is mNumMaterials in size. If the * array. The array is mNumMaterials in size. If the
* AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always * AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always
* be at least ONE material. * be at least ONE material.
*/ */
C_STRUCT aiMaterial** mMaterials; C_STRUCT aiMaterial** mMaterials;
/** The number of animations in the scene. */ /** The number of animations in the scene. */
unsigned int mNumAnimations; unsigned int mNumAnimations;
/** The array of animations. /** The array of animations.
* *
* All animations imported from the given file are listed here. * All animations imported from the given file are listed here.
* The array is mNumAnimations in size. * The array is mNumAnimations in size.
*/ */
C_STRUCT aiAnimation** mAnimations; C_STRUCT aiAnimation** mAnimations;
/** The number of textures embedded into the file */ /** The number of textures embedded into the file */
unsigned int mNumTextures; unsigned int mNumTextures;
/** The array of embedded textures. /** The array of embedded textures.
* *
* Not many file formats embed their textures into the file. * Not many file formats embed their textures into the file.
* An example is Quake's MDL format (which is also used by * An example is Quake's MDL format (which is also used by
* some GameStudio versions) * some GameStudio versions)
*/ */
C_STRUCT aiTexture** mTextures; C_STRUCT aiTexture** mTextures;
/** The number of light sources in the scene. Light sources /** The number of light sources in the scene. Light sources
* are fully optional, in most cases this attribute will be 0 * are fully optional, in most cases this attribute will be 0
*/ */
unsigned int mNumLights; unsigned int mNumLights;
/** The array of light sources. /** The array of light sources.
* *
* All light sources imported from the given file are * All light sources imported from the given file are
* listed here. The array is mNumLights in size. * listed here. The array is mNumLights in size.
*/ */
C_STRUCT aiLight** mLights; C_STRUCT aiLight** mLights;
/** The number of cameras in the scene. Cameras /** The number of cameras in the scene. Cameras
* are fully optional, in most cases this attribute will be 0 * are fully optional, in most cases this attribute will be 0
*/ */
unsigned int mNumCameras; unsigned int mNumCameras;
/** The array of cameras. /** The array of cameras.
* *
* All cameras imported from the given file are listed here. * All cameras imported from the given file are listed here.
* The array is mNumCameras in size. The first camera in the * The array is mNumCameras in size. The first camera in the
* array (if existing) is the default camera view into * array (if existing) is the default camera view into
* the scene. * the scene.
*/ */
C_STRUCT aiCamera** mCameras; C_STRUCT aiCamera** mCameras;
#ifdef __cplusplus #ifdef __cplusplus
//! Default constructor - set everything to 0/NULL //! Default constructor - set everything to 0/NULL
ASSIMP_API aiScene(); ASSIMP_API aiScene();
//! Destructor //! Destructor
ASSIMP_API ~aiScene(); ASSIMP_API ~aiScene();
//! Check whether the scene contains meshes //! Check whether the scene contains meshes
//! Unless no special scene flags are set this will always be true. //! Unless no special scene flags are set this will always be true.
inline bool HasMeshes() const inline bool HasMeshes() const
{ return mMeshes != NULL && mNumMeshes > 0; } { return mMeshes != NULL && mNumMeshes > 0; }
//! Check whether the scene contains materials //! Check whether the scene contains materials
//! Unless no special scene flags are set this will always be true. //! Unless no special scene flags are set this will always be true.
inline bool HasMaterials() const inline bool HasMaterials() const
{ return mMaterials != NULL && mNumMaterials > 0; } { return mMaterials != NULL && mNumMaterials > 0; }
//! Check whether the scene contains lights //! Check whether the scene contains lights
inline bool HasLights() const inline bool HasLights() const
{ return mLights != NULL && mNumLights > 0; } { return mLights != NULL && mNumLights > 0; }
//! Check whether the scene contains textures //! Check whether the scene contains textures
inline bool HasTextures() const inline bool HasTextures() const
{ return mTextures != NULL && mNumTextures > 0; } { return mTextures != NULL && mNumTextures > 0; }
//! Check whether the scene contains cameras //! Check whether the scene contains cameras
inline bool HasCameras() const inline bool HasCameras() const
{ return mCameras != NULL && mNumCameras > 0; } { return mCameras != NULL && mNumCameras > 0; }
//! Check whether the scene contains animations //! Check whether the scene contains animations
inline bool HasAnimations() const inline bool HasAnimations() const
{ return mAnimations != NULL && mNumAnimations > 0; } { return mAnimations != NULL && mNumAnimations > 0; }
#endif // __cplusplus #endif // __cplusplus
/** Internal data, do not touch */ /** Internal data, do not touch */
#ifdef __cplusplus #ifdef __cplusplus
void* mPrivate; void* mPrivate;
#else #else
char* mPrivate; char* mPrivate;
#endif #endif
}; };
#ifdef __cplusplus #ifdef __cplusplus
} //! namespace Assimp } //! namespace Assimp
#endif #endif
#endif // __AI_SCENE_H_INC__ #endif // __AI_SCENE_H_INC__

394
include/assimp/texture.h
View File

@ -1,197 +1,197 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file texture.h /** @file texture.h
* @brief Defines texture helper structures for the library * @brief Defines texture helper structures for the library
* *
* Used for file formats which embed their textures into the model file. * Used for file formats which embed their textures into the model file.
* Supported are both normal textures, which are stored as uncompressed * Supported are both normal textures, which are stored as uncompressed
* pixels, and "compressed" textures, which are stored in a file format * pixels, and "compressed" textures, which are stored in a file format
* such as PNG or TGA. * such as PNG or TGA.
*/ */
#ifndef AI_TEXTURE_H_INC #ifndef AI_TEXTURE_H_INC
#define AI_TEXTURE_H_INC #define AI_TEXTURE_H_INC
#include "types.h" #include "types.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** @def AI_MAKE_EMBEDDED_TEXNAME /** @def AI_MAKE_EMBEDDED_TEXNAME
* Used to build the reserved path name used by the material system to * Used to build the reserved path name used by the material system to
* reference textures that are embedded into their corresponding * reference textures that are embedded into their corresponding
* model files. The parameter specifies the index of the texture * model files. The parameter specifies the index of the texture
* (zero-based, in the aiScene::mTextures array) * (zero-based, in the aiScene::mTextures array)
*/ */
#if (!defined AI_MAKE_EMBEDDED_TEXNAME) #if (!defined AI_MAKE_EMBEDDED_TEXNAME)
# define AI_MAKE_EMBEDDED_TEXNAME(_n_) "*" # _n_ # define AI_MAKE_EMBEDDED_TEXNAME(_n_) "*" # _n_
#endif #endif
#include "./Compiler/pushpack1.h" #include "./Compiler/pushpack1.h"
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** @brief Helper structure to represent a texel in a ARGB8888 format /** @brief Helper structure to represent a texel in a ARGB8888 format
* *
* 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
//! Comparison operator //! Comparison operator
bool operator== (const aiTexel& other) const bool operator== (const aiTexel& other) const
{ {
return b == other.b && r == other.r && return b == other.b && r == other.r &&
g == other.g && a == other.a; g == other.g && a == other.a;
} }
//! Inverse comparison operator //! Inverse comparison operator
bool operator!= (const aiTexel& other) const bool operator!= (const aiTexel& other) const
{ {
return b != other.b || r != other.r || return b != other.b || r != other.r ||
g != other.g || a != other.a; g != other.g || a != other.a;
} }
//! Conversion to a floating-point 4d color //! Conversion to a floating-point 4d color
operator aiColor4D() const operator aiColor4D() const
{ {
return aiColor4D(r/255.f,g/255.f,b/255.f,a/255.f); return aiColor4D(r/255.f,g/255.f,b/255.f,a/255.f);
} }
#endif // __cplusplus #endif // __cplusplus
} PACK_STRUCT; } PACK_STRUCT;
#include "./Compiler/poppack1.h" #include "./Compiler/poppack1.h"
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Helper structure to describe an embedded texture /** Helper structure to describe an embedded texture
* *
* Normally textures are contained in external files but some file formats embed * Normally textures are contained in external files but some file formats embed
* them directly in the model file. There are two types of embedded textures: * them directly in the model file. There are two types of embedded textures:
* 1. Uncompressed textures. The color data is given in an uncompressed format. * 1. Uncompressed textures. The color data is given in an uncompressed format.
* 2. Compressed textures stored in a file format like png or jpg. The raw file * 2. Compressed textures stored in a file format like png or jpg. The raw file
* bytes are given so the application must utilize an image decoder (e.g. DevIL) to * bytes are given so the application must utilize an image decoder (e.g. DevIL) to
* get access to the actual color data. * get access to the actual color data.
*/ */
struct aiTexture struct aiTexture
{ {
/** Width of the texture, in pixels /** Width of the texture, in pixels
* *
* If mHeight is zero the texture is compressed in a format * If mHeight is zero the texture is compressed in a format
* like JPEG. In this case mWidth specifies the size of the * like JPEG. In this case mWidth specifies the size of the
* memory area pcData is pointing to, in bytes. * memory area pcData is pointing to, in bytes.
*/ */
unsigned int mWidth; unsigned int mWidth;
/** Height of the texture, in pixels /** Height of the texture, in pixels
* *
* If this value is zero, pcData points to an compressed texture * If this value is zero, pcData points to an compressed texture
* in any format (e.g. JPEG). * in any format (e.g. JPEG).
*/ */
unsigned int mHeight; unsigned int mHeight;
/** A hint from the loader to make it easier for applications /** A hint from the loader to make it easier for applications
* to determine the type of embedded compressed textures. * to determine the type of embedded compressed textures.
* *
* If mHeight != 0 this member is undefined. Otherwise it * If mHeight != 0 this member is undefined. Otherwise it
* is set set to '\\0\\0\\0\\0' if the loader has no additional * is set set to '\\0\\0\\0\\0' if the loader has no additional
* information about the texture file format used OR the * information about the texture file format used OR the
* file extension of the format without a trailing dot. If there * file extension of the format without a trailing dot. If there
* are multiple file extensions for a format, the shortest * are multiple file extensions for a format, the shortest
* extension is chosen (JPEG maps to 'jpg', not to 'jpeg'). * extension is chosen (JPEG maps to 'jpg', not to 'jpeg').
* E.g. 'dds\\0', 'pcx\\0', 'jpg\\0'. All characters are lower-case. * E.g. 'dds\\0', 'pcx\\0', 'jpg\\0'. All characters are lower-case.
* The fourth character will always be '\\0'. * The fourth character will always be '\\0'.
*/ */
char achFormatHint[4]; char achFormatHint[4];
/** Data of the texture. /** Data of the texture.
* *
* Points to an array of mWidth * mHeight aiTexel's. * Points to an array of mWidth * mHeight aiTexel's.
* The format of the texture data is always ARGB8888 to * The format of the texture data is always ARGB8888 to
* make the implementation for user of the library as easy * make the implementation for user of the library as easy
* as possible. If mHeight = 0 this is a pointer to a memory * as possible. If mHeight = 0 this is a pointer to a memory
* buffer of size mWidth containing the compressed texture * buffer of size mWidth containing the compressed texture
* data. Good luck, have fun! * data. Good luck, have fun!
*/ */
C_STRUCT aiTexel* pcData; C_STRUCT aiTexel* pcData;
#ifdef __cplusplus #ifdef __cplusplus
//! For compressed textures (mHeight == 0): compare the //! For compressed textures (mHeight == 0): compare the
//! format hint against a given string. //! format hint against a given string.
//! @param s Input string. 3 characters are maximally processed. //! @param s Input string. 3 characters are maximally processed.
//! Example values: "jpg", "png" //! Example values: "jpg", "png"
//! @return true if the given string matches the format hint //! @return true if the given string matches the format hint
bool CheckFormat(const char* s) const bool CheckFormat(const char* s) const
{ {
return (0 == ::strncmp(achFormatHint,s,3)); return (0 == ::strncmp(achFormatHint,s,3));
} }
// Construction // Construction
aiTexture () aiTexture ()
: mWidth (0) : mWidth (0)
, mHeight (0) , mHeight (0)
, pcData (NULL) , pcData (NULL)
{ {
achFormatHint[0] = achFormatHint[1] = 0; achFormatHint[0] = achFormatHint[1] = 0;
achFormatHint[2] = achFormatHint[3] = 0; achFormatHint[2] = achFormatHint[3] = 0;
} }
// Destruction // Destruction
~aiTexture () ~aiTexture ()
{ {
delete[] pcData; delete[] pcData;
} }
#endif #endif
}; };
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif // AI_TEXTURE_H_INC #endif // AI_TEXTURE_H_INC

1032
include/assimp/types.h
View File

File diff suppressed because it is too large Load Diff

226
include/assimp/vector2.h
View File

@ -1,113 +1,113 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file vector2.h /** @file vector2.h
* @brief 2D vector structure, including operators when compiling in C++ * @brief 2D vector structure, including operators when compiling in C++
*/ */
#ifndef AI_VECTOR2D_H_INC #ifndef AI_VECTOR2D_H_INC
#define AI_VECTOR2D_H_INC #define AI_VECTOR2D_H_INC
#ifdef __cplusplus #ifdef __cplusplus
# include <cmath> # include <cmath>
#else #else
# include <math.h> # include <math.h>
#endif #endif
#include "./Compiler/pushpack1.h" #include "./Compiler/pushpack1.h"
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
/** Represents a two-dimensional vector. /** Represents a two-dimensional vector.
*/ */
#ifdef __cplusplus #ifdef __cplusplus
template <typename TReal> template <typename TReal>
class aiVector2t class aiVector2t
{ {
public: public:
aiVector2t () : x(), y() {} aiVector2t () : x(), y() {}
aiVector2t (TReal _x, TReal _y) : x(_x), y(_y) {} aiVector2t (TReal _x, TReal _y) : x(_x), y(_y) {}
explicit aiVector2t (TReal _xyz) : x(_xyz), y(_xyz) {} explicit aiVector2t (TReal _xyz) : x(_xyz), y(_xyz) {}
aiVector2t (const aiVector2t& o) : x(o.x), y(o.y) {} aiVector2t (const aiVector2t& o) : x(o.x), y(o.y) {}
public: public:
void Set( TReal pX, TReal pY); void Set( TReal pX, TReal pY);
TReal SquareLength() const ; TReal SquareLength() const ;
TReal Length() const ; TReal Length() const ;
aiVector2t& Normalize(); aiVector2t& Normalize();
public: public:
const aiVector2t& operator += (const aiVector2t& o); const aiVector2t& operator += (const aiVector2t& o);
const aiVector2t& operator -= (const aiVector2t& o); const aiVector2t& operator -= (const aiVector2t& o);
const aiVector2t& operator *= (TReal f); const aiVector2t& operator *= (TReal f);
const aiVector2t& operator /= (TReal f); const aiVector2t& operator /= (TReal f);
TReal operator[](unsigned int i) const; TReal operator[](unsigned int i) const;
TReal& operator[](unsigned int i); TReal& operator[](unsigned int i);
bool operator== (const aiVector2t& other) const; bool operator== (const aiVector2t& other) const;
bool operator!= (const aiVector2t& other) const; bool operator!= (const aiVector2t& other) const;
bool Equal(const aiVector2t& other, TReal epsilon = 1e-6) const; bool Equal(const aiVector2t& other, TReal epsilon = 1e-6) const;
aiVector2t& operator= (TReal f); aiVector2t& operator= (TReal f);
const aiVector2t SymMul(const aiVector2t& o); const aiVector2t SymMul(const aiVector2t& o);
template <typename TOther> template <typename TOther>
operator aiVector2t<TOther> () const; operator aiVector2t<TOther> () const;
TReal x, y; TReal x, y;
} PACK_STRUCT; } PACK_STRUCT;
typedef aiVector2t<float> aiVector2D; typedef aiVector2t<float> aiVector2D;
#else #else
struct aiVector2D { struct aiVector2D {
float x,y; float x,y;
}; };
#endif // __cplusplus #endif // __cplusplus
#include "./Compiler/poppack1.h" #include "./Compiler/poppack1.h"
#endif // AI_VECTOR2D_H_INC #endif // AI_VECTOR2D_H_INC

448
include/assimp/vector2.inl
View File

@ -1,224 +1,224 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file vector2.inl /** @file vector2.inl
* @brief Inline implementation of aiVector2t<TReal> operators * @brief Inline implementation of aiVector2t<TReal> operators
*/ */
#ifndef AI_VECTOR2D_INL_INC #ifndef AI_VECTOR2D_INL_INC
#define AI_VECTOR2D_INL_INC #define AI_VECTOR2D_INL_INC
#ifdef __cplusplus #ifdef __cplusplus
#include "vector2.h" #include "vector2.h"
#include <cmath> #include <cmath>
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
template <typename TOther> template <typename TOther>
aiVector2t<TReal>::operator aiVector2t<TOther> () const { aiVector2t<TReal>::operator aiVector2t<TOther> () const {
return aiVector2t<TOther>(static_cast<TOther>(x),static_cast<TOther>(y)); return aiVector2t<TOther>(static_cast<TOther>(x),static_cast<TOther>(y));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
void aiVector2t<TReal>::Set( TReal pX, TReal pY) { void aiVector2t<TReal>::Set( TReal pX, TReal pY) {
x = pX; y = pY; x = pX; y = pY;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
TReal aiVector2t<TReal>::SquareLength() const { TReal aiVector2t<TReal>::SquareLength() const {
return x*x + y*y; return x*x + y*y;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
TReal aiVector2t<TReal>::Length() const { TReal aiVector2t<TReal>::Length() const {
return std::sqrt( SquareLength()); return std::sqrt( SquareLength());
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
aiVector2t<TReal>& aiVector2t<TReal>::Normalize() { aiVector2t<TReal>& aiVector2t<TReal>::Normalize() {
*this /= Length(); *this /= Length();
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
const aiVector2t<TReal>& aiVector2t<TReal>::operator += (const aiVector2t& o) { const aiVector2t<TReal>& aiVector2t<TReal>::operator += (const aiVector2t& o) {
x += o.x; y += o.y; x += o.x; y += o.y;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
const aiVector2t<TReal>& aiVector2t<TReal>::operator -= (const aiVector2t& o) { const aiVector2t<TReal>& aiVector2t<TReal>::operator -= (const aiVector2t& o) {
x -= o.x; y -= o.y; x -= o.x; y -= o.y;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
const aiVector2t<TReal>& aiVector2t<TReal>::operator *= (TReal f) { const aiVector2t<TReal>& aiVector2t<TReal>::operator *= (TReal f) {
x *= f; y *= f; x *= f; y *= f;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
const aiVector2t<TReal>& aiVector2t<TReal>::operator /= (TReal f) { const aiVector2t<TReal>& aiVector2t<TReal>::operator /= (TReal f) {
x /= f; y /= f; x /= f; y /= f;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
TReal aiVector2t<TReal>::operator[](unsigned int i) const { TReal aiVector2t<TReal>::operator[](unsigned int i) const {
return *(&x + i); return *(&x + i);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
TReal& aiVector2t<TReal>::operator[](unsigned int i) { TReal& aiVector2t<TReal>::operator[](unsigned int i) {
return *(&x + i); return *(&x + i);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
bool aiVector2t<TReal>::operator== (const aiVector2t& other) const { bool aiVector2t<TReal>::operator== (const aiVector2t& other) const {
return x == other.x && y == other.y; return x == other.x && y == other.y;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
bool aiVector2t<TReal>::operator!= (const aiVector2t& other) const { bool aiVector2t<TReal>::operator!= (const aiVector2t& other) const {
return x != other.x || y != other.y; return x != other.x || y != other.y;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
bool aiVector2t<TReal>::Equal(const aiVector2t& other, TReal epsilon) const { bool aiVector2t<TReal>::Equal(const aiVector2t& other, TReal epsilon) const {
return return
std::abs(x - other.x) <= epsilon && std::abs(x - other.x) <= epsilon &&
std::abs(y - other.y) <= epsilon; std::abs(y - other.y) <= epsilon;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
aiVector2t<TReal>& aiVector2t<TReal>::operator= (TReal f) { aiVector2t<TReal>& aiVector2t<TReal>::operator= (TReal f) {
x = y = f; x = y = f;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
const aiVector2t<TReal> aiVector2t<TReal>::SymMul(const aiVector2t& o) { const aiVector2t<TReal> aiVector2t<TReal>::SymMul(const aiVector2t& o) {
return aiVector2t(x*o.x,y*o.y); return aiVector2t(x*o.x,y*o.y);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// symmetric addition // symmetric addition
template <typename TReal> template <typename TReal>
inline aiVector2t<TReal> operator + (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2) inline aiVector2t<TReal> operator + (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2)
{ {
return aiVector2t<TReal>( v1.x + v2.x, v1.y + v2.y); return aiVector2t<TReal>( v1.x + v2.x, v1.y + v2.y);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// symmetric subtraction // symmetric subtraction
template <typename TReal> template <typename TReal>
inline aiVector2t<TReal> operator - (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2) inline aiVector2t<TReal> operator - (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2)
{ {
return aiVector2t<TReal>( v1.x - v2.x, v1.y - v2.y); return aiVector2t<TReal>( v1.x - v2.x, v1.y - v2.y);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// scalar product // scalar product
template <typename TReal> template <typename TReal>
inline TReal operator * (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2) inline TReal operator * (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2)
{ {
return v1.x*v2.x + v1.y*v2.y; return v1.x*v2.x + v1.y*v2.y;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// scalar multiplication // scalar multiplication
template <typename TReal> template <typename TReal>
inline aiVector2t<TReal> operator * ( TReal f, const aiVector2t<TReal>& v) inline aiVector2t<TReal> operator * ( TReal f, const aiVector2t<TReal>& v)
{ {
return aiVector2t<TReal>( f*v.x, f*v.y); return aiVector2t<TReal>( f*v.x, f*v.y);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// and the other way around // and the other way around
template <typename TReal> template <typename TReal>
inline aiVector2t<TReal> operator * ( const aiVector2t<TReal>& v, TReal f) inline aiVector2t<TReal> operator * ( const aiVector2t<TReal>& v, TReal f)
{ {
return aiVector2t<TReal>( f*v.x, f*v.y); return aiVector2t<TReal>( f*v.x, f*v.y);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// scalar division // scalar division
template <typename TReal> template <typename TReal>
inline aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, TReal f) inline aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, TReal f)
{ {
return v * (1/f); return v * (1/f);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// vector division // vector division
template <typename TReal> template <typename TReal>
inline aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, const aiVector2t<TReal>& v2) inline aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, const aiVector2t<TReal>& v2)
{ {
return aiVector2t<TReal>(v.x / v2.x,v.y / v2.y); return aiVector2t<TReal>(v.x / v2.x,v.y / v2.y);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// vector negation // vector negation
template <typename TReal> template <typename TReal>
inline aiVector2t<TReal> operator - ( const aiVector2t<TReal>& v) inline aiVector2t<TReal> operator - ( const aiVector2t<TReal>& v)
{ {
return aiVector2t<TReal>( -v.x, -v.y); return aiVector2t<TReal>( -v.x, -v.y);
} }
#endif #endif
#endif #endif

298
include/assimp/vector3.h
View File

@ -1,149 +1,149 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file vector3.h /** @file vector3.h
* @brief 3D vector structure, including operators when compiling in C++ * @brief 3D vector structure, including operators when compiling in C++
*/ */
#ifndef AI_VECTOR3D_H_INC #ifndef AI_VECTOR3D_H_INC
#define AI_VECTOR3D_H_INC #define AI_VECTOR3D_H_INC
#ifdef __cplusplus #ifdef __cplusplus
# include <cmath> # include <cmath>
#else #else
# include <math.h> # include <math.h>
#endif #endif
#include "./Compiler/pushpack1.h" #include "./Compiler/pushpack1.h"
#ifdef __cplusplus #ifdef __cplusplus
template<typename TReal> class aiMatrix3x3t; template<typename TReal> class aiMatrix3x3t;
template<typename TReal> class aiMatrix4x4t; 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 () : x(), y(), z() {} aiVector3t () : 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) : x(o.x), y(o.y), z(o.z) {} aiVector3t (const aiVector3t& o) : x(o.x), y(o.y), z(o.z) {}
public: 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);
const aiVector3t& operator *= (TReal f); const aiVector3t& operator *= (TReal f);
const aiVector3t& operator /= (TReal f); const aiVector3t& operator /= (TReal f);
// transform vector by matrix // transform vector by matrix
aiVector3t& operator *= (const aiMatrix3x3t<TReal>& mat); aiVector3t& operator *= (const aiMatrix3x3t<TReal>& mat);
aiVector3t& operator *= (const aiMatrix4x4t<TReal>& mat); aiVector3t& operator *= (const aiMatrix4x4t<TReal>& mat);
// access a single element // access a single element
TReal operator[](unsigned int i) const; TReal operator[](unsigned int i) const;
TReal& operator[](unsigned int i); TReal& operator[](unsigned int i);
// comparison // comparison
bool operator== (const aiVector3t& other) const; bool operator== (const aiVector3t& other) const;
bool operator!= (const aiVector3t& other) const; bool operator!= (const aiVector3t& other) const;
bool operator < (const aiVector3t& other) const; bool operator < (const aiVector3t& other) const;
bool Equal(const aiVector3t& other, TReal epsilon = 1e-6) const; bool Equal(const aiVector3t& other, TReal epsilon = 1e-6) const;
template <typename TOther> template <typename TOther>
operator aiVector3t<TOther> () const; operator aiVector3t<TOther> () const;
public: 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
* @param pZ Z component */ * @param pZ Z component */
void Set( TReal pX, TReal pY, TReal pZ); void Set( TReal pX, TReal pY, TReal pZ);
/** @brief Get the squared length of the vector /** @brief Get the squared length of the vector
* @return Square length */ * @return Square length */
TReal SquareLength() const; TReal SquareLength() const;
/** @brief Get the length of the vector /** @brief Get the length of the vector
* @return length */ * @return length */
TReal Length() const; TReal Length() const;
/** @brief Normalize the vector */ /** @brief Normalize the vector */
aiVector3t& Normalize(); aiVector3t& Normalize();
/** @brief Componentwise multiplication of two vectors /** @brief Componentwise multiplication of two vectors
* *
* Note that vec*vec yields the dot product. * Note that vec*vec yields the dot product.
* @param o Second factor */ * @param o Second factor */
const aiVector3t SymMul(const aiVector3t& o); const aiVector3t SymMul(const aiVector3t& o);
TReal x, y, z; TReal x, y, z;
} PACK_STRUCT; } PACK_STRUCT;
typedef aiVector3t<float> aiVector3D; typedef aiVector3t<float> aiVector3D;
#else #else
struct aiVector3D { struct aiVector3D {
float x,y,z; float x,y,z;
} PACK_STRUCT; } PACK_STRUCT;
#endif // __cplusplus #endif // __cplusplus
#include "./Compiler/poppack1.h" #include "./Compiler/poppack1.h"
#ifdef __cplusplus #ifdef __cplusplus
#endif // __cplusplus #endif // __cplusplus
#endif // AI_VECTOR3D_H_INC #endif // AI_VECTOR3D_H_INC

456
include/assimp/vector3.inl
View File

@ -1,228 +1,228 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file vector3.inl /** @file vector3.inl
* @brief Inline implementation of aiVector3t<TReal> operators * @brief Inline implementation of aiVector3t<TReal> operators
*/ */
#ifndef AI_VECTOR3D_INL_INC #ifndef AI_VECTOR3D_INL_INC
#define AI_VECTOR3D_INL_INC #define AI_VECTOR3D_INL_INC
#ifdef __cplusplus #ifdef __cplusplus
#include "vector3.h" #include "vector3.h"
#include <cmath> #include <cmath>
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
/** Transformation of a vector by a 3x3 matrix */ /** Transformation of a vector by a 3x3 matrix */
template <typename TReal> template <typename TReal>
inline aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) inline aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const aiVector3t<TReal>& pVector)
{ {
aiVector3t<TReal> res; aiVector3t<TReal> res;
res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z; res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z;
res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z; res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z;
res.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z; res.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z;
return res; return res;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
/** Transformation of a vector by a 4x4 matrix */ /** Transformation of a vector by a 4x4 matrix */
template <typename TReal> template <typename TReal>
inline aiVector3t<TReal> operator * (const aiMatrix4x4t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) inline aiVector3t<TReal> operator * (const aiMatrix4x4t<TReal>& pMatrix, const aiVector3t<TReal>& pVector)
{ {
aiVector3t<TReal> res; aiVector3t<TReal> res;
res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z + pMatrix.a4; res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z + pMatrix.a4;
res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z + pMatrix.b4; res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z + pMatrix.b4;
res.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z + pMatrix.c4; res.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z + pMatrix.c4;
return res; return res;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
template <typename TOther> template <typename TOther>
aiVector3t<TReal>::operator aiVector3t<TOther> () const { aiVector3t<TReal>::operator aiVector3t<TOther> () const {
return aiVector3t<TOther>(static_cast<TOther>(x),static_cast<TOther>(y),static_cast<TOther>(z)); return aiVector3t<TOther>(static_cast<TOther>(x),static_cast<TOther>(y),static_cast<TOther>(z));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE void aiVector3t<TReal>::Set( TReal pX, TReal pY, TReal pZ) { AI_FORCE_INLINE void aiVector3t<TReal>::Set( TReal pX, TReal pY, TReal pZ) {
x = pX; y = pY; z = pZ; x = pX; y = pY; z = pZ;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE TReal aiVector3t<TReal>::SquareLength() const { AI_FORCE_INLINE TReal aiVector3t<TReal>::SquareLength() const {
return x*x + y*y + z*z; return x*x + y*y + z*z;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE TReal aiVector3t<TReal>::Length() const { AI_FORCE_INLINE TReal aiVector3t<TReal>::Length() const {
return std::sqrt( SquareLength()); return std::sqrt( SquareLength());
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::Normalize() { AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::Normalize() {
*this /= Length(); return *this; *this /= Length(); return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator += (const aiVector3t<TReal>& o) { AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator += (const aiVector3t<TReal>& o) {
x += o.x; y += o.y; z += o.z; return *this; x += o.x; y += o.y; z += o.z; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator -= (const aiVector3t<TReal>& o) { AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator -= (const aiVector3t<TReal>& o) {
x -= o.x; y -= o.y; z -= o.z; return *this; x -= o.x; y -= o.y; z -= o.z; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator *= (TReal f) { AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator *= (TReal f) {
x *= f; y *= f; z *= f; return *this; x *= f; y *= f; z *= f; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator /= (TReal f) { AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator /= (TReal f) {
x /= f; y /= f; z /= f; return *this; x /= f; y /= f; z /= f; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& mat){ AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& mat){
return(*this = mat * (*this)); return(*this = mat * (*this));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix4x4t<TReal>& mat){ AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix4x4t<TReal>& mat){
return(*this = mat * (*this)); return(*this = mat * (*this));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE TReal aiVector3t<TReal>::operator[](unsigned int i) const { AI_FORCE_INLINE TReal aiVector3t<TReal>::operator[](unsigned int i) const {
return *(&x + i); return *(&x + i);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE TReal& aiVector3t<TReal>::operator[](unsigned int i) { AI_FORCE_INLINE TReal& aiVector3t<TReal>::operator[](unsigned int i) {
return *(&x + i); return *(&x + i);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE bool aiVector3t<TReal>::operator== (const aiVector3t<TReal>& other) const { AI_FORCE_INLINE bool aiVector3t<TReal>::operator== (const aiVector3t<TReal>& other) const {
return x == other.x && y == other.y && z == other.z; return x == other.x && y == other.y && z == other.z;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE bool aiVector3t<TReal>::operator!= (const aiVector3t<TReal>& other) const { AI_FORCE_INLINE bool aiVector3t<TReal>::operator!= (const aiVector3t<TReal>& other) const {
return x != other.x || y != other.y || z != other.z; return x != other.x || y != other.y || z != other.z;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
AI_FORCE_INLINE bool aiVector3t<TReal>::Equal(const aiVector3t<TReal>& other, TReal epsilon) const { AI_FORCE_INLINE bool aiVector3t<TReal>::Equal(const aiVector3t<TReal>& other, TReal epsilon) const {
return return
std::abs(x - other.x) <= epsilon && std::abs(x - other.x) <= epsilon &&
std::abs(y - other.y) <= epsilon && std::abs(y - other.y) <= epsilon &&
std::abs(z - other.z) <= epsilon; std::abs(z - other.z) <= epsilon;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE bool aiVector3t<TReal>::operator < (const aiVector3t<TReal>& other) const { AI_FORCE_INLINE bool aiVector3t<TReal>::operator < (const aiVector3t<TReal>& other) const {
return x != other.x ? x < other.x : y != other.y ? y < other.y : z < other.z; return x != other.x ? x < other.x : y != other.y ? y < other.y : z < other.z;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiVector3t<TReal> aiVector3t<TReal>::SymMul(const aiVector3t<TReal>& o) { AI_FORCE_INLINE const aiVector3t<TReal> aiVector3t<TReal>::SymMul(const aiVector3t<TReal>& o) {
return aiVector3t<TReal>(x*o.x,y*o.y,z*o.z); return aiVector3t<TReal>(x*o.x,y*o.y,z*o.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// symmetric addition // symmetric addition
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator + (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) { AI_FORCE_INLINE aiVector3t<TReal> operator + (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
return aiVector3t<TReal>( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z); return aiVector3t<TReal>( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// symmetric subtraction // symmetric subtraction
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator - (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) { AI_FORCE_INLINE aiVector3t<TReal> operator - (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
return aiVector3t<TReal>( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z); return aiVector3t<TReal>( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// scalar product // scalar product
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE TReal operator * (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) { AI_FORCE_INLINE TReal operator * (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z; return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// scalar multiplication // scalar multiplication
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator * ( TReal f, const aiVector3t<TReal>& v) { AI_FORCE_INLINE aiVector3t<TReal> operator * ( TReal f, const aiVector3t<TReal>& v) {
return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z); return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// and the other way around // and the other way around
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator * ( const aiVector3t<TReal>& v, TReal f) { AI_FORCE_INLINE aiVector3t<TReal> operator * ( const aiVector3t<TReal>& v, TReal f) {
return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z); return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// scalar division // scalar division
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, TReal f) { AI_FORCE_INLINE aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, TReal f) {
return v * (1/f); return v * (1/f);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// vector division // vector division
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, const aiVector3t<TReal>& v2) { AI_FORCE_INLINE aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, const aiVector3t<TReal>& v2) {
return aiVector3t<TReal>(v.x / v2.x,v.y / v2.y,v.z / v2.z); return aiVector3t<TReal>(v.x / v2.x,v.y / v2.y,v.z / v2.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// cross product // cross product
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator ^ ( const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) { AI_FORCE_INLINE aiVector3t<TReal> operator ^ ( const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
return aiVector3t<TReal>( v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x); return aiVector3t<TReal>( v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// vector negation // vector negation
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator - ( const aiVector3t<TReal>& v) { AI_FORCE_INLINE aiVector3t<TReal> operator - ( const aiVector3t<TReal>& v) {
return aiVector3t<TReal>( -v.x, -v.y, -v.z); return aiVector3t<TReal>( -v.x, -v.y, -v.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
#endif // __cplusplus #endif // __cplusplus
#endif // AI_VECTOR3D_INL_INC #endif // AI_VECTOR3D_INL_INC

210
include/assimp/version.h
View File

@ -1,105 +1,105 @@
/* /*
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Open Asset Import Library (assimp) Open Asset Import Library (assimp)
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
Copyright (c) 2006-2015, assimp team Copyright (c) 2006-2015, 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,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer. following disclaimer.
* Redistributions in binary form must reproduce the above * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other following disclaimer in the documentation and/or other
materials provided with the distribution. materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its * Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products contributors may be used to endorse or promote products
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
/** @file version.h /** @file version.h
* @brief Functions to query the version of the Assimp runtime, check * @brief Functions to query the version of the Assimp runtime, check
* compile flags, ... * compile flags, ...
*/ */
#ifndef INCLUDED_AI_VERSION_H #ifndef INCLUDED_AI_VERSION_H
#define INCLUDED_AI_VERSION_H #define INCLUDED_AI_VERSION_H
#include "defs.h" #include "defs.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Returns a string with legal copyright and licensing information /** @brief Returns a string with legal copyright and licensing information
* about Assimp. The string may include multiple lines. * about Assimp. The string may include multiple lines.
* @return Pointer to static string. * @return Pointer to static string.
*/ */
ASSIMP_API const char* aiGetLegalString (void); ASSIMP_API const char* aiGetLegalString (void);
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Returns the current minor version number of Assimp. /** @brief Returns the current minor version number of Assimp.
* @return Minor version of the Assimp runtime the application was * @return Minor version of the Assimp runtime the application was
* linked/built against * linked/built against
*/ */
ASSIMP_API unsigned int aiGetVersionMinor (void); ASSIMP_API unsigned int aiGetVersionMinor (void);
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Returns the current major version number of Assimp. /** @brief Returns the current major version number of Assimp.
* @return Major version of the Assimp runtime the application was * @return Major version of the Assimp runtime the application was
* linked/built against * linked/built against
*/ */
ASSIMP_API unsigned int aiGetVersionMajor (void); ASSIMP_API unsigned int aiGetVersionMajor (void);
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Returns the repository revision of the Assimp runtime. /** @brief Returns the repository revision of the Assimp runtime.
* @return SVN Repository revision number of the Assimp runtime the * @return SVN Repository revision number of the Assimp runtime the
* application was linked/built against. * application was linked/built against.
*/ */
ASSIMP_API unsigned int aiGetVersionRevision (void); ASSIMP_API unsigned int aiGetVersionRevision (void);
//! Assimp was compiled as a shared object (Windows: DLL) //! Assimp was compiled as a shared object (Windows: DLL)
#define ASSIMP_CFLAGS_SHARED 0x1 #define ASSIMP_CFLAGS_SHARED 0x1
//! Assimp was compiled against STLport //! Assimp was compiled against STLport
#define ASSIMP_CFLAGS_STLPORT 0x2 #define ASSIMP_CFLAGS_STLPORT 0x2
//! Assimp was compiled as a debug build //! Assimp was compiled as a debug build
#define ASSIMP_CFLAGS_DEBUG 0x4 #define ASSIMP_CFLAGS_DEBUG 0x4
//! Assimp was compiled with ASSIMP_BUILD_BOOST_WORKAROUND defined //! Assimp was compiled with ASSIMP_BUILD_BOOST_WORKAROUND defined
#define ASSIMP_CFLAGS_NOBOOST 0x8 #define ASSIMP_CFLAGS_NOBOOST 0x8
//! Assimp was compiled with ASSIMP_BUILD_SINGLETHREADED defined //! Assimp was compiled with ASSIMP_BUILD_SINGLETHREADED defined
#define ASSIMP_CFLAGS_SINGLETHREADED 0x10 #define ASSIMP_CFLAGS_SINGLETHREADED 0x10
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Returns assimp's compile flags /** @brief Returns assimp's compile flags
* @return Any bitwise combination of the ASSIMP_CFLAGS_xxx constants. * @return Any bitwise combination of the ASSIMP_CFLAGS_xxx constants.
*/ */
ASSIMP_API unsigned int aiGetCompileFlags (void); ASSIMP_API unsigned int aiGetCompileFlags (void);
#ifdef __cplusplus #ifdef __cplusplus
} // end extern "C" } // end extern "C"
#endif #endif
#endif // !! #ifndef INCLUDED_AI_VERSION_H #endif // !! #ifndef INCLUDED_AI_VERSION_H