diff options
Diffstat (limited to '3rdparty/assimp/include')
36 files changed, 0 insertions, 10464 deletions
diff --git a/3rdparty/assimp/include/Compiler/poppack1.h b/3rdparty/assimp/include/Compiler/poppack1.h deleted file mode 100644 index 8944b2b6..00000000 --- a/3rdparty/assimp/include/Compiler/poppack1.h +++ /dev/null @@ -1,22 +0,0 @@ - -// =============================================================================== -// May be included multiple times - resets structure packing to the defaults -// for all supported compilers. Reverts the changes made by #include <pushpack1.h> -// -// Currently this works on the following compilers: -// MSVC 7,8,9 -// GCC -// BORLAND (complains about 'pack state changed but not reverted', but works) -// =============================================================================== - -#ifndef AI_PUSHPACK_IS_DEFINED -# error pushpack1.h must be included after poppack1.h -#endif - -// reset packing to the original value -#if defined(_MSC_VER) || defined(__BORLANDC__) || defined (__BCPLUSPLUS__) -# pragma pack( pop ) -#endif -#undef PACK_STRUCT - -#undef AI_PUSHPACK_IS_DEFINED diff --git a/3rdparty/assimp/include/Compiler/pushpack1.h b/3rdparty/assimp/include/Compiler/pushpack1.h deleted file mode 100644 index b89a8ff7..00000000 --- a/3rdparty/assimp/include/Compiler/pushpack1.h +++ /dev/null @@ -1,42 +0,0 @@ - - -// =============================================================================== -// May be included multiple times - sets structure packing to 1 -// for all supported compilers. #include <poppack1.h> reverts the changes. -// -// Currently this works on the following compilers: -// MSVC 7,8,9 -// GCC -// BORLAND (complains about 'pack state changed but not reverted', but works) -// -// -// USAGE: -// -// struct StructToBePacked { -// } PACK_STRUCT; -// -// =============================================================================== - -#ifdef AI_PUSHPACK_IS_DEFINED -# error poppack1.h must be included after pushpack1.h -#endif - -#if defined(_MSC_VER) || defined(__BORLANDC__) || defined (__BCPLUSPLUS__) -# pragma pack(push,1) -# define PACK_STRUCT -#elif defined( __GNUC__ ) -# define PACK_STRUCT __attribute__((packed)) -#else -# define PACK_STRUCT -//# error Compiler not supported -#endif - -#if defined(_MSC_VER) - -// C4103: Packing was changed after the inclusion of the header, propably missing #pragma pop -# pragma warning (disable : 4103) -#endif - -#define AI_PUSHPACK_IS_DEFINED - - diff --git a/3rdparty/assimp/include/DefaultLogger.h b/3rdparty/assimp/include/DefaultLogger.h deleted file mode 100644 index 6d939d6a..00000000 --- a/3rdparty/assimp/include/DefaultLogger.h +++ /dev/null @@ -1,190 +0,0 @@ -/* -Open Asset Import Library (ASSIMP) ----------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ -/** @file DefaultLogger.h -*/ - -#ifndef INCLUDED_AI_DEFAULTLOGGER -#define INCLUDED_AI_DEFAULTLOGGER - -#include "Logger.h" -#include "LogStream.h" -#include "NullLogger.h" -#include <vector> - -namespace Assimp { -// ------------------------------------------------------------------------------------ -class IOStream; -struct LogStreamInfo; - -/** default name of logfile */ -#define ASSIMP_DEFAULT_LOG_NAME "AssimpLog.txt" - -// ------------------------------------------------------------------------------------ -/** @brief CPP-API: Primary logging facility of Assimp. - * - * The library stores its primary #Logger as a static member of this class. - * #get() returns this primary logger. By default the underlying implementation is - * 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 - * attach to the logger. Some default streams for common streaming locations (such as - * a file, std::cout, OutputDebugString()) are also provided. - * - * If you wish to customize the logging at an even deeper level supply your own - * implementation of #Logger to #set(). - * @note The whole logging stuff causes a small extra overhead for all imports. */ -class ASSIMP_API DefaultLogger : - public Logger { - -public: - - // ---------------------------------------------------------------------- - /** @brief Creates a logging instance. - * @param name Name for log file. Only valid in combination - * with the aiDefaultLogStream_FILE flag. - * @param severity Log severity, VERBOSE turns on debug messages - * @param defStreams Default log streams to be attached. Any bitwise - * combination of the aiDefaultLogStream enumerated values. - * If #aiDefaultLogStream_FILE is specified but an empty string is - * passed for 'name', no log file is created at all. - * @param io IOSystem to be used to open external files (such as the - * log file). Pass NULL to rely on the default implementation. - * This replaces the default #NullLogger with a #DefaultLogger instance. */ - static Logger *create(const char* name = ASSIMP_DEFAULT_LOG_NAME, - LogSeverity severity = NORMAL, - unsigned int defStreams = aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE, - IOSystem* io = NULL); - - // ---------------------------------------------------------------------- - /** @brief Setup a custom #Logger implementation. - * - * Use this if the provided #DefaultLogger class doesn't fit into - * your needs. If the provided message formatting is OK for you, - * it's much easier to use #create() and to attach your own custom - * output streams to it. - * @param logger Pass NULL to setup a default NullLogger*/ - static void set (Logger *logger); - - // ---------------------------------------------------------------------- - /** @brief Getter for singleton instance - * @return Only instance. This is never null, but it could be a - * NullLogger. Use isNullLogger to check this.*/ - static Logger *get(); - - // ---------------------------------------------------------------------- - /** @brief Return whether a #NullLogger is currently active - * @return true if the current logger is a #NullLogger. - * Use create() or set() to setup a logger that does actually do - * something else than just rejecting all log messages. */ - static bool isNullLogger(); - - // ---------------------------------------------------------------------- - /** @brief Kills the current singleton logger and replaces it with a - * #NullLogger instance. */ - static void kill(); - - // ---------------------------------------------------------------------- - /** @copydoc Logger::attachStream */ - bool attachStream(LogStream *pStream, - unsigned int severity); - - // ---------------------------------------------------------------------- - /** @copydoc Logger::detatchStream */ - bool detatchStream(LogStream *pStream, - unsigned int severity); - - -private: - - // ---------------------------------------------------------------------- - /** @briefPrivate construction for internal use by create(). - * @param severity Logging granularity */ - DefaultLogger(LogSeverity severity); - - // ---------------------------------------------------------------------- - /** @briefDestructor */ - ~DefaultLogger(); - -private: - - /** @brief Logs debug infos, only been written when severity level VERBOSE is set */ - void OnDebug(const char* message); - - /** @brief Logs an info message */ - void OnInfo(const char* message); - - /** @brief Logs a warning message */ - void OnWarn(const char* message); - - /** @brief Logs an error message */ - void OnError(const char* message); - - // ---------------------------------------------------------------------- - /** @brief Writes a message to all streams */ - void WriteToStreams(const char* message, ErrorSeverity ErrorSev ); - - // ---------------------------------------------------------------------- - /** @brief Returns the thread id. - * @note This is an OS specific feature, if not supported, a - * zero will be returned. - */ - unsigned int GetThreadID(); - -private: - // Aliases for stream container - typedef std::vector<LogStreamInfo*> StreamArray; - typedef std::vector<LogStreamInfo*>::iterator StreamIt; - typedef std::vector<LogStreamInfo*>::const_iterator ConstStreamIt; - - //! only logging instance - static Logger *m_pLogger; - static NullLogger s_pNullLogger; - - //! Attached streams - StreamArray m_StreamArray; - - bool noRepeatMsg; - char lastMsg[MAX_LOG_MESSAGE_LENGTH*2]; - size_t lastLen; -}; -// ------------------------------------------------------------------------------------ - -} // Namespace Assimp - -#endif // !! INCLUDED_AI_DEFAULTLOGGER diff --git a/3rdparty/assimp/include/IOStream.h b/3rdparty/assimp/include/IOStream.h deleted file mode 100644 index 22fdbde9..00000000 --- a/3rdparty/assimp/include/IOStream.h +++ /dev/null @@ -1,135 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ -/** @file IOStream.h - * @brief File I/O wrappers for C++. - */ - -#ifndef AI_IOSTREAM_H_INC -#define AI_IOSTREAM_H_INC - -#include "aiTypes.h" - -#ifndef __cplusplus -# error This header requires C++ to be used. aiFileIO.h is the \ - corresponding C interface. -#endif - -namespace Assimp { - -// ---------------------------------------------------------------------------------- -/** @brief CPP-API: Class to handle file I/O for C++ - * - * 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 - * implementation for IOSystem that creates instances of your custom IO class. -*/ -class ASSIMP_API IOStream : public Intern::AllocateFromAssimpHeap -{ -protected: - /** Constructor protected, use IOSystem::Open() to create an instance. */ - IOStream(void); - -public: - // ------------------------------------------------------------------- - /** @brief Destructor. Deleting the object closes the underlying file, - * alternatively you may use IOSystem::Close() to release the file. - */ - virtual ~IOStream(); - - // ------------------------------------------------------------------- - /** @brief Read from the file - * - * See fread() for more details - * This fails for write-only files */ - virtual size_t Read(void* pvBuffer, - size_t pSize, - size_t pCount) = 0; - - // ------------------------------------------------------------------- - /** @brief Write to the file - * - * See fwrite() for more details - * This fails for read-only files */ - virtual size_t Write(const void* pvBuffer, - size_t pSize, - size_t pCount) = 0; - - // ------------------------------------------------------------------- - /** @brief Set the read/write cursor of the file - * - * Note that the offset is _negative_ for aiOrigin_END. - * See fseek() for more details */ - virtual aiReturn Seek(size_t pOffset, - aiOrigin pOrigin) = 0; - - // ------------------------------------------------------------------- - /** @brief Get the current position of the read/write cursor - * - * See ftell() for more details */ - virtual size_t Tell() const = 0; - - // ------------------------------------------------------------------- - /** @brief Returns filesize - * Returns the filesize. */ - virtual size_t FileSize() const = 0; - - // ------------------------------------------------------------------- - /** @brief Flush the contents of the file buffer (for writers) - * See fflush() for more details. - */ - virtual void Flush() = 0; -}; //! class IOStream - -// ---------------------------------------------------------------------------------- -inline IOStream::IOStream() -{ - // empty -} - -// ---------------------------------------------------------------------------------- -inline IOStream::~IOStream() -{ - // empty -} -// ---------------------------------------------------------------------------------- -} //!namespace Assimp - -#endif //!!AI_IOSTREAM_H_INC diff --git a/3rdparty/assimp/include/IOSystem.h b/3rdparty/assimp/include/IOSystem.h deleted file mode 100644 index f41dda90..00000000 --- a/3rdparty/assimp/include/IOSystem.h +++ /dev/null @@ -1,222 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file IOSystem.h - * @brief File system wrapper for C++. Inherit this class to supply - * custom file handling logic to the Import library. -*/ - -#ifndef AI_IOSYSTEM_H_INC -#define AI_IOSYSTEM_H_INC - -#ifndef __cplusplus -# error This header requires C++ to be used. aiFileIO.h is the \ - corresponding C interface. -#endif - -#include "aiTypes.h" -namespace Assimp { -class IOStream; - -// --------------------------------------------------------------------------- -/** @brief CPP-API: Interface to the file system. - * - * 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 - * supply a custom implementation for IOStream. - * - * @see Importer::SetIOHandler() */ -class ASSIMP_API IOSystem : public Intern::AllocateFromAssimpHeap -{ -public: - - // ------------------------------------------------------------------- - /** @brief Default constructor. - * - * Create an instance of your derived class and assign it to an - * #Assimp::Importer instance by calling Importer::SetIOHandler(). - */ - IOSystem(); - - // ------------------------------------------------------------------- - /** @brief Virtual destructor. - * - * It is safe to be called from within DLL Assimp, we're constructed - * on Assimp's heap. - */ - virtual ~IOSystem(); - - -public: - - // ------------------------------------------------------------------- - /** @brief For backward compatibility - * @see Exists(const char*) - */ - AI_FORCE_INLINE bool Exists( const std::string& pFile) const; - - // ------------------------------------------------------------------- - /** @brief Tests for the existence of a file at the given path. - * - * @param pFile Path to the file - * @return true if there is a file with this path, else false. - */ - - virtual bool Exists( const char* pFile) const = 0; - - - - // ------------------------------------------------------------------- - /** @brief Returns the system specific directory separator - * @return System specific directory separator - */ - virtual char getOsSeparator() const = 0; - - - // ------------------------------------------------------------------- - /** @brief Open a new file with a given path. - * - * When the access to the file is finished, call Close() to release - * all associated resources (or the virtual dtor of the IOStream). - * - * @param pFile Path to the file - * @param pMode Desired file I/O mode. Required are: "wb", "w", "wt", - * "rb", "r", "rt". - * - * @return New IOStream interface allowing the lib to access - * the underlying file. - * @note When implementing this class to provide custom IO handling, - * you probably have to supply an own implementation of IOStream as well. - */ - virtual IOStream* Open(const char* pFile, - const char* pMode = "rb") = 0; - - // ------------------------------------------------------------------- - /** @brief For backward compatibility - * @see Open(const char*, const char*) - */ - inline IOStream* Open(const std::string& pFile, - const std::string& pMode = std::string("rb")); - - - - // ------------------------------------------------------------------- - /** @brief Closes the given file and releases all resources - * associated with it. - * @param pFile The file instance previously created by Open(). - */ - virtual void Close( IOStream* pFile) = 0; - - // ------------------------------------------------------------------- - /** @brief Compares two paths and check whether the point to - * identical files. - * - * The dummy implementation of this virtual performs a - * case-insensitive comparison of the given strings. The default IO - * system implementation uses OS mechanisms to convert relative into - * absolute paths, so the result can be trusted. - * @param one First file - * @param second Second file - * @return true if the paths point to the same file. The file needn't - * be existing, however. - */ - virtual bool ComparePaths (const char* one, - const char* second) const; - - // ------------------------------------------------------------------- - /** @brief For backward compatibility - * @see ComparePaths(const char*, const char*) - */ - inline bool ComparePaths (const std::string& one, - const std::string& second) const; -}; - -// ---------------------------------------------------------------------------- -AI_FORCE_INLINE IOSystem::IOSystem() -{ - // empty -} - -// ---------------------------------------------------------------------------- -AI_FORCE_INLINE IOSystem::~IOSystem() -{ - // empty -} - -// ---------------------------------------------------------------------------- -// For compatibility, the interface of some functions taking a std::string was -// changed to const char* to avoid crashes between binary incompatible STL -// versions. This code her is inlined, so it shouldn't cause any problems. -// ---------------------------------------------------------------------------- - -// ---------------------------------------------------------------------------- -AI_FORCE_INLINE IOStream* IOSystem::Open(const std::string& pFile, - const std::string& pMode) -{ - // NOTE: - // For compatibility, interface was changed to const char* to - // avoid crashes between binary incompatible STL versions - return Open(pFile.c_str(),pMode.c_str()); -} - -// ---------------------------------------------------------------------------- -AI_FORCE_INLINE bool IOSystem::Exists( const std::string& pFile) const -{ - // NOTE: - // For compatibility, interface was changed to const char* to - // avoid crashes between binary incompatible STL versions - return Exists(pFile.c_str()); -} - -// ---------------------------------------------------------------------------- -inline bool IOSystem::ComparePaths (const std::string& one, - const std::string& second) const -{ - // NOTE: - // For compatibility, interface was changed to const char* to - // avoid crashes between binary incompatible STL versions - return ComparePaths(one.c_str(),second.c_str()); -} - -// ---------------------------------------------------------------------------- -} //!ns Assimp - -#endif //AI_IOSYSTEM_H_INC diff --git a/3rdparty/assimp/include/LogStream.h b/3rdparty/assimp/include/LogStream.h deleted file mode 100644 index 760a9f65..00000000 --- a/3rdparty/assimp/include/LogStream.h +++ /dev/null @@ -1,93 +0,0 @@ -/* -Open Asset Import Library (ASSIMP) ----------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ - -/** @file LogStream.h - * @brief Abstract base class 'LogStream', representing an output log stream. - */ -#ifndef INCLUDED_AI_LOGSTREAM_H -#define INCLUDED_AI_LOGSTREAM_H -#include "aiTypes.h" -namespace Assimp { -class IOSystem; - -// ------------------------------------------------------------------------------------ -/** @brief CPP-API: Abstract interface for log stream implementations. - * - * Several default implementations are provided, see #aiDefaultLogStream for more - * details. Writing your own implementation of LogStream is just necessary if these - * are not enough for your purpose. */ -class ASSIMP_API LogStream - : public Intern::AllocateFromAssimpHeap { -protected: - /** @brief Default constructor */ - LogStream() { - } -public: - /** @brief Virtual destructor */ - virtual ~LogStream() { - } - - // ------------------------------------------------------------------- - /** @brief Overwrite this for your own output methods - * - * Log messages *may* consist of multiple lines and you shouldn't - * expect a consistent formatting. If you want custom formatting - * (e.g. generate HTML), supply a custom instance of Logger to - * #DefaultLogger:set(). Usually you can *expect* that a log message - * is exactly one line and terminated with a single \n character. - * @param message Message to be written */ - virtual void write(const char* message) = 0; - - // ------------------------------------------------------------------- - /** @brief Creates a default log stream - * @param streams Type of the default stream - * @param name For aiDefaultLogStream_FILE: name of the output file - * @param io For aiDefaultLogStream_FILE: IOSystem to be used to open the output - * file. Pass NULL for the default implementation. - * @return New LogStream instance. */ - static LogStream* createDefaultStream(aiDefaultLogStream stream, - const char* name = "AssimpLog.txt", - IOSystem* io = NULL); - -}; // !class LogStream -// ------------------------------------------------------------------------------------ -} // Namespace Assimp - -#endif diff --git a/3rdparty/assimp/include/Logger.h b/3rdparty/assimp/include/Logger.h deleted file mode 100644 index 94a42141..00000000 --- a/3rdparty/assimp/include/Logger.h +++ /dev/null @@ -1,234 +0,0 @@ -/* -Open Asset Import Library (ASSIMP) ----------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ - -/** @file Logger.h - * @brief Abstract base class 'Logger', base of the logging system. - */ -#ifndef INCLUDED_AI_LOGGER_H -#define INCLUDED_AI_LOGGER_H - -#include "aiTypes.h" -namespace Assimp { -class LogStream; - -// Maximum length of a log message. Longer messages are rejected. -#define MAX_LOG_MESSAGE_LENGTH 1024u - -// ---------------------------------------------------------------------------------- -/** @brief CPP-API: Abstract interface for logger implementations. - * Assimp provides a default implementation and uses it for almost all - * logging stuff ('DefaultLogger'). This class defines just basic logging - * behaviour and is not of interest for you. Instead, take a look at #DefaultLogger. */ -class ASSIMP_API Logger - : public Intern::AllocateFromAssimpHeap { -public: - - // ---------------------------------------------------------------------- - /** @enum LogSeverity - * @brief Log severity to describe the granularity of logging. - */ - enum LogSeverity - { - NORMAL, //!< Normal granularity of logging - VERBOSE //!< Debug infos will be logged, too - }; - - // ---------------------------------------------------------------------- - /** @enum ErrorSeverity - * @brief Description for severity of a log message. - * - * Every LogStream has a bitwise combination of these flags. - * A LogStream doesn't receive any messages of a specific type - * if it doesn't specify the corresponding ErrorSeverity flag. - */ - enum ErrorSeverity - { - DEBUGGING = 1, //!< Debug log message - INFO = 2, //!< Info log message - WARN = 4, //!< Warn log message - ERR = 8 //!< Error log message - }; - -public: - - /** @brief Virtual destructor */ - virtual ~Logger(); - - // ---------------------------------------------------------------------- - /** @brief Writes a debug message - * @param message Debug message*/ - void debug(const std::string &message); - - // ---------------------------------------------------------------------- - /** @brief Writes a info message - * @param message Info message*/ - void info(const std::string &message); - - // ---------------------------------------------------------------------- - /** @brief Writes a warning message - * @param message Warn message*/ - void warn(const std::string &message); - - // ---------------------------------------------------------------------- - /** @brief Writes an error message - * @param message Error message*/ - void error(const std::string &message); - - // ---------------------------------------------------------------------- - /** @brief Set a new log severity. - * @param log_severity New severity for logging*/ - void setLogSeverity(LogSeverity log_severity); - - // ---------------------------------------------------------------------- - /** @brief Get the current log severity*/ - LogSeverity getLogSeverity() const; - - // ---------------------------------------------------------------------- - /** @brief Attach a new logstream - * - * The logger takes ownership of the stream and is responsible - * for its destruction (which is done using ::delete when the logger - * itself is destroyed). Call detachStream to detach a stream and to - * gain ownership of it again. - * @param pStream Logstream to attach - * @param severity Message filter, specified which types of log - * messages are dispatched to the stream. Provide a bitwise - * combination of the ErrorSeverity flags. - * @return true if the stream has been attached, false otherwise.*/ - virtual bool attachStream(LogStream *pStream, - unsigned int severity = DEBUGGING | ERR | WARN | INFO) = 0; - - // ---------------------------------------------------------------------- - /** @brief Detach a still attached stream from the logger (or - * modify the filter flags bits) - * @param pStream Logstream instance for detaching - * @param severity Provide a bitwise combination of the ErrorSeverity - * 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 - * the caller retakes the possession of the stream. - * @return true if the stream has been dettached, false otherwise.*/ - virtual bool detatchStream(LogStream *pStream, - unsigned int severity = DEBUGGING | ERR | WARN | INFO) = 0; - -protected: - - /** Default constructor */ - Logger(); - - /** Construction with a given log severity */ - Logger(LogSeverity severity); - - // ---------------------------------------------------------------------- - /** @brief Called as a request to write a specific debug message - * @param message Debug message. Never longer than - * MAX_LOG_MESSAGE_LENGTH characters (exluding the '0'). - * @note The message string is only valid until the scope of - * the function is left. - */ - virtual void OnDebug(const char* message)= 0; - - // ---------------------------------------------------------------------- - /** @brief Called as a request to write a specific info message - * @param message Info message. Never longer than - * MAX_LOG_MESSAGE_LENGTH characters (exluding the '0'). - * @note The message string is only valid until the scope of - * the function is left. - */ - virtual void OnInfo(const char* message) = 0; - - // ---------------------------------------------------------------------- - /** @brief Called as a request to write a specific warn message - * @param message Warn message. Never longer than - * MAX_LOG_MESSAGE_LENGTH characters (exluding the '0'). - * @note The message string is only valid until the scope of - * the function is left. - */ - virtual void OnWarn(const char* essage) = 0; - - // ---------------------------------------------------------------------- - /** @brief Called as a request to write a specific error message - * @param message Error message. Never longer than - * MAX_LOG_MESSAGE_LENGTH characters (exluding the '0'). - * @note The message string is only valid until the scope of - * the function is left. - */ - virtual void OnError(const char* message) = 0; - -protected: - - //! Logger severity - LogSeverity m_Severity; -}; - -// ---------------------------------------------------------------------------------- -// Default constructor -inline Logger::Logger() { - setLogSeverity(NORMAL); -} - -// ---------------------------------------------------------------------------------- -// Virtual destructor -inline Logger::~Logger() -{ -} - -// ---------------------------------------------------------------------------------- -// Construction with given logging severity -inline Logger::Logger(LogSeverity severity) { - setLogSeverity(severity); -} - -// ---------------------------------------------------------------------------------- -// Log severity setter -inline void Logger::setLogSeverity(LogSeverity log_severity){ - m_Severity = log_severity; -} - -// ---------------------------------------------------------------------------------- -// Log severity getter -inline Logger::LogSeverity Logger::getLogSeverity() const { - return m_Severity; -} - -// ---------------------------------------------------------------------------------- - -} // Namespace Assimp - -#endif // !! INCLUDED_AI_LOGGER_H diff --git a/3rdparty/assimp/include/NullLogger.h b/3rdparty/assimp/include/NullLogger.h deleted file mode 100644 index 152abafa..00000000 --- a/3rdparty/assimp/include/NullLogger.h +++ /dev/null @@ -1,95 +0,0 @@ -/* -Open Asset Import Library (ASSIMP) ----------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ - -/** @file NullLogger.h - * @brief Dummy logger -*/ - -#ifndef INCLUDED_AI_NULLLOGGER_H -#define INCLUDED_AI_NULLLOGGER_H - -#include "Logger.h" -namespace Assimp { -// --------------------------------------------------------------------------- -/** @brief CPP-API: Empty logging implementation. - * - * Does nothing! Used by default if the application hasn't requested a - * custom logger via #DefaultLogger::set() or #DefaultLogger::create(); */ -class ASSIMP_API NullLogger - : public Logger { - -public: - - /** @brief Logs a debug message */ - void OnDebug(const char* message) { - (void)message; //this avoids compiler warnings - } - - /** @brief Logs an info message */ - void OnInfo(const char* message) { - (void)message; //this avoids compiler warnings - } - - /** @brief Logs a warning message */ - void OnWarn(const char* message) { - (void)message; //this avoids compiler warnings - } - - /** @brief Logs an error message */ - void OnError(const char* message) { - (void)message; //this avoids compiler warnings - } - - /** @brief Detach a still attached stream from logger */ - bool attachStream(LogStream *pStream, unsigned int severity) { - (void)pStream; (void)severity; //this avoids compiler warnings - return false; - } - - /** @brief Detach a still attached stream from logger */ - bool detatchStream(LogStream *pStream, unsigned int severity) { - (void)pStream; (void)severity; //this avoids compiler warnings - return false; - } - -private: -}; -} -#endif // !! AI_NULLLOGGER_H_INCLUDED diff --git a/3rdparty/assimp/include/ProgressHandler.h b/3rdparty/assimp/include/ProgressHandler.h deleted file mode 100644 index 24c393d3..00000000 --- a/3rdparty/assimp/include/ProgressHandler.h +++ /dev/null @@ -1,93 +0,0 @@ -/* -Open Asset Import Library (ASSIMP) ----------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ - -/** @file ProgressHandler.h - * @brief Abstract base class 'ProgressHandler'. - */ -#ifndef INCLUDED_AI_PROGRESSHANDLER_H -#define INCLUDED_AI_PROGRESSHANDLER_H -#include "aiTypes.h" -namespace Assimp { - -// ------------------------------------------------------------------------------------ -/** @brief CPP-API: Abstract interface for custom progress report receivers. - * - * Each #Importer instance maintains its own #ProgressHandler. The default - * implementation provided by Assimp doesn't do anything at all. */ -class ASSIMP_API ProgressHandler - : public Intern::AllocateFromAssimpHeap { -protected: - /** @brief Default constructor */ - ProgressHandler () { - } -public: - /** @brief Virtual destructor */ - virtual ~ProgressHandler () { - } - - // ------------------------------------------------------------------- - /** @brief Progress callback. - * @param percentage An estimate of the current loading progress, - * in percent. Or -1.f if such an estimate is not available. - * - * There are restriction on what you may do from within your - * implementation of this method: no exceptions may be thrown and no - * non-const #Importer methods may be called. It is - * not generally possible to predict the number of callbacks - * fired during a single import. - * - * @return Return false to abort loading at the next possible - * occasion (loaders and Assimp are generally allowed to perform - * all needed cleanup tasks prior to returning control to the - * caller). If the loading is aborted, #Importer::ReadFile() - * returns always NULL. - * - * @note Currently, percentage is always -1.f because there is - * no reliable way to compute it. - * */ - virtual bool Update(float percentage = -1.f) = 0; - - - -}; // !class ProgressHandler -// ------------------------------------------------------------------------------------ -} // Namespace Assimp - -#endif diff --git a/3rdparty/assimp/include/aiAnim.h b/3rdparty/assimp/include/aiAnim.h deleted file mode 100644 index a9e9a491..00000000 --- a/3rdparty/assimp/include/aiAnim.h +++ /dev/null @@ -1,484 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiAnim.h - * @brief Defines the data structures in which the imported animations - * are returned. - */ -#ifndef AI_ANIM_H_INC -#define AI_ANIM_H_INC - -#include "aiTypes.h" -#include "aiQuaternion.h" - -#ifdef __cplusplus -extern "C" { -#endif - -// --------------------------------------------------------------------------- -/** A time-value pair specifying a certain 3D vector for the given time. */ -struct aiVectorKey -{ - /** The time of this key */ - double mTime; - - /** The value of this key */ - C_STRUCT aiVector3D mValue; - -#ifdef __cplusplus - - //! Default constructor - aiVectorKey(){} - - //! Construction from a given time and key value - aiVectorKey(double time, const aiVector3D& value) - : mTime (time) - , mValue (value) - {} - - - typedef aiVector3D elem_type; - - // Comparison operators. For use with std::find(); - bool operator == (const aiVectorKey& o) const { - return o.mValue == this->mValue; - } - bool operator != (const aiVectorKey& o) const { - return o.mValue != this->mValue; - } - - // Relational operators. For use with std::sort(); - bool operator < (const aiVectorKey& o) const { - return mTime < o.mTime; - } - bool operator > (const aiVectorKey& o) const { - return mTime > o.mTime; - } -#endif -}; - -// --------------------------------------------------------------------------- -/** A time-value pair specifying a rotation for the given time. - * Rotations are expressed with quaternions. */ -struct aiQuatKey -{ - /** The time of this key */ - double mTime; - - /** The value of this key */ - C_STRUCT aiQuaternion mValue; - -#ifdef __cplusplus - aiQuatKey(){ - } - - /** Construction from a given time and key value */ - aiQuatKey(double time, const aiQuaternion& value) - : mTime (time) - , mValue (value) - {} - - typedef aiQuaternion elem_type; - - // Comparison operators. For use with std::find(); - bool operator == (const aiQuatKey& o) const { - return o.mValue == this->mValue; - } - bool operator != (const aiQuatKey& o) const { - return o.mValue != this->mValue; - } - - // Relational operators. For use with std::sort(); - bool operator < (const aiQuatKey& o) const { - return mTime < o.mTime; - } - bool operator > (const aiQuatKey& o) const { - return mTime > o.mTime; - } -#endif -}; - -// --------------------------------------------------------------------------- -/** Binds a anim mesh to a specific point in time. */ -struct aiMeshKey -{ - /** The time of this key */ - double mTime; - - /** Index into the aiMesh::mAnimMeshes array of the - * mesh coresponding to the #aiMeshAnim hosting this - * key frame. The referenced anim mesh is evaluated - * according to the rules defined in the docs for #aiAnimMesh.*/ - unsigned int mValue; - -#ifdef __cplusplus - - aiMeshKey() { - } - - /** Construction from a given time and key value */ - aiMeshKey(double time, const unsigned int value) - : mTime (time) - , mValue (value) - {} - - typedef unsigned int elem_type; - - // Comparison operators. For use with std::find(); - bool operator == (const aiMeshKey& o) const { - return o.mValue == this->mValue; - } - bool operator != (const aiMeshKey& o) const { - return o.mValue != this->mValue; - } - - // Relational operators. For use with std::sort(); - bool operator < (const aiMeshKey& o) const { - return mTime < o.mTime; - } - bool operator > (const aiMeshKey& o) const { - return mTime > o.mTime; - } - -#endif -}; - -// --------------------------------------------------------------------------- -/** Defines how an animation channel behaves outside the defined time - * range. This corresponds to aiNodeAnim::mPreState and - * aiNodeAnim::mPostState.*/ -enum aiAnimBehaviour -{ - /** The value from the default node transformation is taken*/ - aiAnimBehaviour_DEFAULT = 0x0, - - /** The nearest key value is used without interpolation */ - aiAnimBehaviour_CONSTANT = 0x1, - - /** The value of the nearest two keys is linearly - * extrapolated for the current time value.*/ - aiAnimBehaviour_LINEAR = 0x2, - - /** The animation is repeated. - * - * If the animation key go from n to m and the current - * time is t, use the value at (t-n) % (|m-n|).*/ - aiAnimBehaviour_REPEAT = 0x3, - - - - /** This value is not used, it is just here to force the - * the compiler to map this enum to a 32 Bit integer */ -#ifndef SWIG - _aiAnimBehaviour_Force32Bit = 0x8fffffff -#endif -}; - -// --------------------------------------------------------------------------- -/** Describes the animation of a single node. The name specifies the - * bone/node which is affected by this animation channel. The keyframes - * are given in three separate series of values, one each for position, - * rotation and scaling. The transformation matrix computed from these - * values replaces the node's original transformation matrix at a - * specific time. - * This means all keys are absolute and not relative to the bone default pose. - * The order in which the transformations are applied is - * - as usual - scaling, rotation, translation. - * - * @note All keys are returned in their correct, chronological order. - * Duplicate keys don't pass the validation step. Most likely there - * will be no negative time values, but they are not forbidden also ( so - * implementations need to cope with them! ) */ -struct aiNodeAnim -{ - /** The name of the node affected by this animation. The node - * must exist and it must be unique.*/ - C_STRUCT aiString mNodeName; - - /** The number of position keys */ - unsigned int mNumPositionKeys; - - /** The position keys of this animation channel. Positions are - * specified as 3D vector. The array is mNumPositionKeys in size. - * - * If there are position keys, there will also be at least one - * scaling and one rotation key.*/ - C_STRUCT aiVectorKey* mPositionKeys; - - /** The number of rotation keys */ - unsigned int mNumRotationKeys; - - /** The rotation keys of this animation channel. Rotations are - * given as quaternions, which are 4D vectors. The array is - * mNumRotationKeys in size. - * - * If there are rotation keys, there will also be at least one - * scaling and one position key. */ - C_STRUCT aiQuatKey* mRotationKeys; - - - /** The number of scaling keys */ - unsigned int mNumScalingKeys; - - /** The scaling keys of this animation channel. Scalings are - * specified as 3D vector. The array is mNumScalingKeys in size. - * - * If there are scaling keys, there will also be at least one - * position and one rotation key.*/ - C_STRUCT aiVectorKey* mScalingKeys; - - - /** Defines how the animation behaves before the first - * key is encountered. - * - * The default value is aiAnimBehaviour_DEFAULT (the original - * transformation matrix of the affected node is used).*/ - C_ENUM aiAnimBehaviour mPreState; - - /** Defines how the animation behaves after the last - * key was processed. - * - * The default value is aiAnimBehaviour_DEFAULT (the original - * transformation matrix of the affected node is taken).*/ - C_ENUM aiAnimBehaviour mPostState; - -#ifdef __cplusplus - aiNodeAnim() - { - mNumPositionKeys = 0; mPositionKeys = NULL; - mNumRotationKeys = 0; mRotationKeys = NULL; - mNumScalingKeys = 0; mScalingKeys = NULL; - - mPreState = mPostState = aiAnimBehaviour_DEFAULT; - } - - ~aiNodeAnim() - { - delete [] mPositionKeys; - delete [] mRotationKeys; - delete [] mScalingKeys; - } -#endif // __cplusplus -}; - -// --------------------------------------------------------------------------- -/** Describes vertex-based animations for a single mesh or a group of - * meshes. Meshes carry the animation data for each frame in their - * aiMesh::mAnimMeshes array. The purpose of aiMeshAnim is to - * define keyframes linking each mesh attachment to a particular - * point in time. */ -struct aiMeshAnim -{ - /** Name of the mesh to be animated. An empty string is not allowed, - * animated meshes need to be named (not necessarily uniquely, - * the name can basically serve as wildcard to select a group - * of meshes with similar animation setup)*/ - C_STRUCT aiString mName; - - /** Size of the #mKeys array. Must be 1, at least. */ - unsigned int mNumKeys; - - /** Key frames of the animation. May not be NULL. */ - C_STRUCT aiMeshKey* mKeys; - -#ifdef __cplusplus - - aiMeshAnim() - : mNumKeys() - , mKeys() - {} - - ~aiMeshAnim() - { - delete[] mKeys; - } - -#endif -}; - -// --------------------------------------------------------------------------- -/** 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.*/ -struct aiAnimation -{ - /** The name of the animation. If the modeling package this data was - * exported from does support only a single animation channel, this - * name is usually empty (length is zero). */ - C_STRUCT aiString mName; - - /** Duration of the animation in ticks. */ - double mDuration; - - /** Ticks per second. 0 if not specified in the imported file */ - double mTicksPerSecond; - - /** The number of bone animation channels. Each channel affects - * a single node. */ - unsigned int mNumChannels; - - /** The node animation channels. Each channel affects a single node. - * The array is mNumChannels in size. */ - C_STRUCT aiNodeAnim** mChannels; - - - /** The number of mesh animation channels. Each channel affects - * a single mesh and defines vertex-based animation. */ - unsigned int mNumMeshChannels; - - /** The mesh animation channels. Each channel affects a single mesh. - * The array is mNumMeshChannels in size. */ - C_STRUCT aiMeshAnim** mMeshChannels; - -#ifdef __cplusplus - aiAnimation() - : mDuration(-1.) - , mTicksPerSecond() - , mNumChannels() - , mChannels() - , mNumMeshChannels() - , mMeshChannels() - { - } - - ~aiAnimation() - { - // DO NOT REMOVE THIS ADDITIONAL CHECK - if (mNumChannels && mChannels) { - for ( unsigned int a = 0; a < mNumChannels; a++) { - delete mChannels[a]; - } - - delete [] mChannels; - } - if (mNumMeshChannels && mMeshChannels) { - for ( unsigned int a = 0; a < mNumMeshChannels; a++) { - delete mMeshChannels[a]; - } - - delete [] mMeshChannels; - } - } -#endif // __cplusplus -}; - -#ifdef __cplusplus -} - - -// some C++ utilities for inter- and extrapolation -namespace Assimp { - -// --------------------------------------------------------------------------- -/** @brief CPP-API: Utility class to simplify interpolations of various data types. - * - * The type of interpolation is choosen automatically depending on the - * types of the arguments. */ -template <typename T> -struct Interpolator -{ - // ------------------------------------------------------------------ - /** @brief Get the result of the interpolation between a,b. - * - * The interpolation algorithm depends on the type of the operands. - * aiQuaternion's and aiQuatKey's SLERP, the rest does a simple - * linear interpolation. */ - void operator () (T& out,const T& a, const T& b, float d) const { - out = a + (b-a)*d; - } -}; // ! Interpolator <T> - -//! @cond Never - -template <> -struct Interpolator <aiQuaternion> { - void operator () (aiQuaternion& out,const aiQuaternion& a, - const aiQuaternion& b, float d) const - { - aiQuaternion::Interpolate(out,a,b,d); - } -}; // ! Interpolator <aiQuaternion> - -template <> -struct Interpolator <unsigned int> { - void operator () (unsigned int& out,unsigned int a, - unsigned int b, float d) const - { - out = d>0.5f ? b : a; - } -}; // ! Interpolator <aiQuaternion> - -template <> -struct Interpolator <aiVectorKey> { - void operator () (aiVector3D& out,const aiVectorKey& a, - const aiVectorKey& b, float d) const - { - Interpolator<aiVector3D> ipl; - ipl(out,a.mValue,b.mValue,d); - } -}; // ! Interpolator <aiVectorKey> - -template <> -struct Interpolator <aiQuatKey> { - void operator () (aiQuaternion& out, const aiQuatKey a, - const aiQuatKey& b, float d) const - { - Interpolator<aiQuaternion> ipl; - ipl(out,a.mValue,b.mValue,d); - } -}; // ! Interpolator <aiQuatKey> - -template <> -struct Interpolator <aiMeshKey> { - void operator () (unsigned int& out, const aiMeshKey a, - const aiMeshKey& b, float d) const - { - Interpolator<unsigned int> ipl; - ipl(out,a.mValue,b.mValue,d); - } -}; // ! Interpolator <aiQuatKey> - -//! @endcond -} // ! end namespace Assimp - - - -#endif // __cplusplus -#endif // AI_ANIM_H_INC diff --git a/3rdparty/assimp/include/aiAssert.h b/3rdparty/assimp/include/aiAssert.h deleted file mode 100644 index 5e00d846..00000000 --- a/3rdparty/assimp/include/aiAssert.h +++ /dev/null @@ -1,30 +0,0 @@ -/** @file aiAssert.h - */ -#ifndef AI_DEBUG_H_INC -#define AI_DEBUG_H_INC - -#include <string> - -#ifndef __cplusplus -#error This header requires C++ to be used. -#endif - -namespace Assimp { - -//! \brief ASSIMP specific assertion test, only works in debug mode -//! \param uiLine Line in file -//! \param file Source file -AI_WONT_RETURN void aiAssert(const std::string &message, unsigned int uiLine, const std::string &file); - - -//! \def ai_assert -//! \brief ASSIMP specific assertion test -#ifdef DEBUG -# define ai_assert(expression) if ( !(expression)) Assimp::aiAssert( #expression, __LINE__, __FILE__); -#else -# define ai_assert(expression) -#endif - -} // Namespace Assimp - -#endif diff --git a/3rdparty/assimp/include/aiCamera.h b/3rdparty/assimp/include/aiCamera.h deleted file mode 100644 index 8f3d0a71..00000000 --- a/3rdparty/assimp/include/aiCamera.h +++ /dev/null @@ -1,223 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiCamera.h - * @brief Defines the aiCamera data structure - */ - -#ifndef AI_CAMERA_H_INC -#define AI_CAMERA_H_INC - -#include "aiTypes.h" - -#ifdef __cplusplus -extern "C" { -#endif - -// --------------------------------------------------------------------------- -/** Helper structure to describe a virtual camera. - * - * 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 - * scenegraph. This means, any values such as the look-at vector are not - * *absolute*, they're <b>relative</b> to the coordinate system defined - * by the node which corresponds to the camera. This allows for camera - * animations. For static cameras parameters like the 'look-at' or 'up' vectors - * are usually specified directly in aiCamera, but beware, they could also - * be encoded in the node transformation. The following (pseudo)code sample - * shows how to do it: <br><br> - * @code - * // Get the camera matrix for a camera at a specific time - * // if the node hierarchy for the camera does not contain - * // at least one animated node this is a static computation - * get-camera-matrix (node sceneRoot, camera cam) : matrix - * { - * node cnd = find-node-for-camera(cam) - * matrix cmt = identity() - * - * // as usual - get the absolute camera transformation for this frame - * for each node nd in hierarchy from sceneRoot to cnd - * matrix cur - * if (is-animated(nd)) - * cur = eval-animation(nd) - * else cur = nd->mTransformation; - * cmt = mult-matrices( cmt, cur ) - * end for - * - * // now multiply with the camera's own local transform - * cam = mult-matrices (cam, get-camera-matrix(cmt) ) - * } - * @endcode - * - * @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 - * writes the target point as a subnode of the camera's main node, - * called "<camName>.Target". However this is just additional information - * then the transformation tracks of the camera main node make the - * camera already look in the right direction. - * -*/ -struct aiCamera -{ - /** The name of the camera. - * - * There must be a node in the scenegraph with the same name. - * This node specifies the position of the camera in the scene - * hierarchy and can be animated. - */ - C_STRUCT aiString mName; - - /** Position of the camera relative to the coordinate space - * defined by the corresponding node. - * - * The default value is 0|0|0. - */ - C_STRUCT aiVector3D mPosition; - - - /** 'Up' - vector of the camera coordinate system relative to - * the coordinate space defined by the corresponding node. - * - * The 'right' vector of the camera coordinate system is - * the cross product of the up and lookAt vectors. - * The default value is 0|1|0. The vector - * may be normalized, but it needn't. - */ - C_STRUCT aiVector3D mUp; - - - /** 'LookAt' - vector of the camera coordinate system relative to - * the coordinate space defined by the corresponding node. - * - * This is the viewing direction of the user. - * The default value is 0|0|1. The vector - * may be normalized, but it needn't. - */ - C_STRUCT aiVector3D mLookAt; - - - /** Half horizontal field of view angle, in radians. - * - * The field of view angle is the angle between the center - * line of the screen and the left or right border. - * The default value is 1/4PI. - */ - float mHorizontalFOV; - - /** Distance of the near clipping plane from the camera. - * - * The value may not be 0.f (for arithmetic reasons to prevent - * a division through zero). The default value is 0.1f. - */ - float mClipPlaneNear; - - /** Distance of the far clipping plane from the camera. - * - * The far clipping plane must, of course, be further away than the - * near clipping plane. The default value is 1000.f. The ratio - * between the near and the far plane should not be too - * large (between 1000-10000 should be ok) to avoid floating-point - * inaccuracies which could lead to z-fighting. - */ - float mClipPlaneFar; - - - /** Screen aspect ratio. - * - * 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 - * 0 if the aspect ratio is not defined in the source file. - * 0 is also the default value. - */ - float mAspect; - -#ifdef __cplusplus - - aiCamera() - : mUp (0.f,1.f,0.f) - , mLookAt (0.f,0.f,1.f) - , mHorizontalFOV (0.25f * (float)AI_MATH_PI) - , mClipPlaneNear (0.1f) - , mClipPlaneFar (1000.f) - , mAspect (0.f) - {} - - /** @brief Get a *right-handed* camera matrix from me - * @param out Camera matrix to be filled - */ - void GetCameraMatrix (aiMatrix4x4& out) const - { - /** todo: test ... should work, but i'm not absolutely sure */ - - /** We don't know whether these vectors are already normalized ...*/ - aiVector3D zaxis = mLookAt; zaxis.Normalize(); - aiVector3D yaxis = mUp; yaxis.Normalize(); - aiVector3D xaxis = mUp^mLookAt; xaxis.Normalize(); - - out.a4 = -(xaxis * mPosition); - out.b4 = -(yaxis * mPosition); - out.c4 = -(zaxis * mPosition); - - out.a1 = xaxis.x; - out.a2 = xaxis.y; - out.a3 = xaxis.z; - - out.b1 = yaxis.x; - out.b2 = yaxis.y; - out.b3 = yaxis.z; - - out.c1 = zaxis.x; - out.c2 = zaxis.y; - out.c3 = zaxis.z; - - out.d1 = out.d2 = out.d3 = 0.f; - out.d4 = 1.f; - } - -#endif -}; - - -#ifdef __cplusplus -} -#endif - -#endif // AI_CAMERA_H_INC diff --git a/3rdparty/assimp/include/aiColor4D.h b/3rdparty/assimp/include/aiColor4D.h deleted file mode 100644 index ce7e9dfe..00000000 --- a/3rdparty/assimp/include/aiColor4D.h +++ /dev/null @@ -1,94 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ -/** @file aiColor4D.h - * @brief RGBA color structure, including operators when compiling in C++ - */ -#ifndef AI_COLOR4D_H_INC -#define AI_COLOR4D_H_INC - -#ifdef __cplusplus -extern "C" { -#endif - -#include "./Compiler/pushpack1.h" -// ---------------------------------------------------------------------------------- -/** Represents a color in Red-Green-Blue space including an -* alpha component. Color values range from 0 to 1. */ -// ---------------------------------------------------------------------------------- -struct aiColor4D -{ -#ifdef __cplusplus - aiColor4D () : r(0.0f), g(0.0f), b(0.0f), a(0.0f) {} - aiColor4D (float _r, float _g, float _b, float _a) - : r(_r), g(_g), b(_b), a(_a) {} - aiColor4D (float _r) : r(_r), g(_r), b(_r), a(_r) {} - aiColor4D (const aiColor4D& o) - : r(o.r), g(o.g), b(o.b), a(o.a) {} - - // combined operators - const aiColor4D& operator += (const aiColor4D& o); - const aiColor4D& operator -= (const aiColor4D& o); - const aiColor4D& operator *= (float f); - const aiColor4D& operator /= (float f); - - // comparison - bool operator == (const aiColor4D& other) const; - bool operator != (const aiColor4D& other) const; - - // color tuple access, rgba order - inline float operator[](unsigned int i) const; - inline float& operator[](unsigned int i); - - /** check whether a color is (close to) black */ - inline bool IsBlack() const; - -#endif // !__cplusplus - - // Red, green, blue and alpha color values - float r, g, b, a; -} PACK_STRUCT; // !struct aiColor4D - -#include "./Compiler/poppack1.h" -#ifdef __cplusplus -} // end extern "C" - -#endif // __cplusplus -#endif // AI_VECTOR3D_H_INC diff --git a/3rdparty/assimp/include/aiColor4D.inl b/3rdparty/assimp/include/aiColor4D.inl deleted file mode 100644 index a4985ead..00000000 --- a/3rdparty/assimp/include/aiColor4D.inl +++ /dev/null @@ -1,140 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiColor4D.inl - * @brief Inline implementation of aiColor4D operators - */ -#ifndef AI_COLOR4D_INL_INC -#define AI_COLOR4D_INL_INC - -#include "aiColor4D.h" -#ifdef __cplusplus - -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE const aiColor4D& aiColor4D::operator += (const aiColor4D& o) { - r += o.r; g += o.g; b += o.b; a += o.a; return *this; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE const aiColor4D& aiColor4D::operator -= (const aiColor4D& o) { - r -= o.r; g -= o.g; b -= o.b; a -= o.a; return *this; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE const aiColor4D& aiColor4D::operator *= (float f) { - r *= f; g *= f; b *= f; a *= f; return *this; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE const aiColor4D& aiColor4D::operator /= (float f) { - r /= f; g /= f; b /= f; a /= f; return *this; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE float aiColor4D::operator[](unsigned int i) const { - return *(&r + i); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE float& aiColor4D::operator[](unsigned int i) { - return *(&r + i); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE bool aiColor4D::operator== (const aiColor4D& other) const { - return r == other.r && g == other.g && b == other.b && a == other.a; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE bool aiColor4D::operator!= (const aiColor4D& other) const { - return r != other.r || g != other.g || b != other.b || a != other.a; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE aiColor4D operator + (const aiColor4D& v1, const aiColor4D& v2) { - return aiColor4D( v1.r + v2.r, v1.g + v2.g, v1.b + v2.b, v1.a + v2.a); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE aiColor4D operator - (const aiColor4D& v1, const aiColor4D& v2) { - return aiColor4D( v1.r - v2.r, v1.g - v2.g, v1.b - v2.b, v1.a - v2.a); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE aiColor4D operator * (const aiColor4D& v1, const aiColor4D& v2) { - return aiColor4D( v1.r * v2.r, v1.g * v2.g, v1.b * v2.b, v1.a * v2.a); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE aiColor4D operator / (const aiColor4D& v1, const aiColor4D& v2) { - return aiColor4D( v1.r / v2.r, v1.g / v2.g, v1.b / v2.b, v1.a / v2.a); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE aiColor4D operator * ( float f, const aiColor4D& v) { - return aiColor4D( f*v.r, f*v.g, f*v.b, f*v.a); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE aiColor4D operator * ( const aiColor4D& v, float f) { - return aiColor4D( f*v.r, f*v.g, f*v.b, f*v.a); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE aiColor4D operator / ( const aiColor4D& v, float f) { - return v * (1/f); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE aiColor4D operator / ( float f,const aiColor4D& v) { - return aiColor4D(f,f,f,f)/v; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE aiColor4D operator + ( const aiColor4D& v, float f) { - return aiColor4D( f+v.r, f+v.g, f+v.b, f+v.a); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE aiColor4D operator - ( const aiColor4D& v, float f) { - return aiColor4D( v.r-f, v.g-f, v.b-f, v.a-f); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE aiColor4D operator + ( float f, const aiColor4D& v) { - return aiColor4D( f+v.r, f+v.g, f+v.b, f+v.a); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE aiColor4D operator - ( float f, const aiColor4D& v) { - return aiColor4D( f-v.r, f-v.g, f-v.b, f-v.a); -} - -// ------------------------------------------------------------------------------------------------ -inline bool aiColor4D :: IsBlack() const { - // The alpha component doesn't care here. black is black. - static const float epsilon = 10e-3f; - return fabs( r ) < epsilon && fabs( g ) < epsilon && fabs( b ) < epsilon; -} - -#endif // __cplusplus -#endif // AI_VECTOR3D_INL_INC diff --git a/3rdparty/assimp/include/aiConfig.h b/3rdparty/assimp/include/aiConfig.h deleted file mode 100644 index e53a2870..00000000 --- a/3rdparty/assimp/include/aiConfig.h +++ /dev/null @@ -1,634 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiConfig.h - * @brief Defines constants for configurable properties for the library - * - * Typically these properties are set via - * #Assimp::Importer::SetPropertyFloat, - * #Assimp::Importer::SetPropertyInteger or - * #Assimp::Importer::SetPropertyString, - * depending on the data type of a property. All properties have a - * default value. See the doc for the mentioned methods for more details. - * - * <br><br> - * The corresponding functions for use with the plain-c API are: - * #aiSetImportPropertyInteger, - * #aiSetImportPropertyFloat, - * #aiSetImportPropertyString - */ -#ifndef INCLUDED_AI_CONFIG_H -#define INCLUDED_AI_CONFIG_H - - -// ########################################################################### -// LIBRARY SETTINGS -// General, global settings -// ########################################################################### - -// --------------------------------------------------------------------------- -/** @brief Enables time measurements. - * - * If enabled, measures the time needed for each part of the loading - * process (i.e. IO time, importing, postprocessing, ..) and dumps - * these timings to the DefaultLogger. See the @link perf Performance - * Page@endlink for more information on this topic. - * - * Property type: bool. Default value: false. - */ -#define AI_CONFIG_GLOB_MEASURE_TIME \ - "GLOB_MEASURE_TIME" - -# if 0 // not implemented yet -// --------------------------------------------------------------------------- -/** @brief Set Assimp's multithreading policy. - * - * This setting is ignored if Assimp was built without boost.thread - * support (ASSIMP_BUILD_NO_THREADING, which is implied by ASSIMP_BUILD_BOOST_WORKAROUND). - * Possible values are: -1 to let Assimp decide what to do, 0 to disable - * multithreading entirely and any number larger than 0 to force a specific - * number of threads. Assimp is always free to ignore this settings, which is - * merely a hint. Usually, the default value (-1) will be fine. However, if - * Assimp is used concurrently from multiple user threads, it might be useful - * to limit each Importer instance to a specific number of cores. - * - * For more information, see the @link threading Threading page@endlink. - * Property type: int, default value: -1. - */ -#define AI_CONFIG_GLOB_MULTITHREADING \ - "GLOB_MULTITHREADING" -#endif - -// ########################################################################### -// POST PROCESSING SETTINGS -// Various stuff to fine-tune the behavior of a specific post processing step. -// ########################################################################### - -// --------------------------------------------------------------------------- -/** @brief Specifies the maximum angle that may be between two vertex tangents - * that their tangents and bitangents are smoothed. - * - * This applies to the CalcTangentSpace-Step. The angle is specified - * in degrees, so 180 is PI. The default value is - * 45 degrees. The maximum value is 175. - * Property type: float. - */ -#define AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE \ - "PP_CT_MAX_SMOOTHING_ANGLE" - -// --------------------------------------------------------------------------- -/** @brief Specifies the maximum angle that may be between two face normals - * at the same vertex position that their are smoothed together. - * - * Sometimes referred to as 'crease angle'. - * This applies to the GenSmoothNormals-Step. The angle is specified - * in degrees, so 180 is PI. The default value is 175 degrees (all vertex - * normals are smoothed). The maximum value is 175, too. Property type: float. - * Warning: setting this option may cause a severe loss of performance. The - * performance is unaffected if the #AI_CONFIG_FAVOUR_SPEED flag is set but - * the output quality may be reduced. - */ -#define AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE \ - "PP_GSN_MAX_SMOOTHING_ANGLE" - -// --------------------------------------------------------------------------- -/** @brief Sets the colormap (= palette) to be used to decode embedded - * textures in MDL (Quake or 3DGS) files. - * - * This must be a valid path to a file. The file is 768 (256*3) bytes - * large and contains RGB triplets for each of the 256 palette entries. - * The default value is colormap.lmp. If the file is not found, - * a default palette (from Quake 1) is used. - * Property type: string. - */ -#define AI_CONFIG_IMPORT_MDL_COLORMAP \ - "IMPORT_MDL_COLORMAP" - -// --------------------------------------------------------------------------- -/** @brief Configures the #aiProcess_RemoveRedundantMaterials step to - * keep materials matching a name in a given list. - * - * This is a list of 1 to n strings, ' ' serves as delimiter character. - * Identifiers containing whitespaces must be enclosed in *single* - * quotation marks. For example:<tt> - * "keep-me and_me_to anotherMaterialToBeKept \'name with whitespace\'"</tt>. - * If a material matches on of these names, it will not be modified or - * removed by the postprocessing step nor will other materials be replaced - * by a reference to it. <br> - * This option might be useful if you are using some magic material names - * to pass additional semantics through the content pipeline. This ensures - * they won't be optimized away, but a general optimization is still - * performed for materials not contained in the list. - * Property type: String. Default value: n/a - * @note Linefeeds, tabs or carriage returns are treated as whitespace. - * Material names are case sensitive. - */ -#define AI_CONFIG_PP_RRM_EXCLUDE_LIST \ - "PP_RRM_EXCLUDE_LIST" - -// --------------------------------------------------------------------------- -/** @brief Configures the #aiProcess_PretransformVertices step to - * keep the scene hierarchy. Meshes are moved to worldspace, but - * no optimization is performed (read: meshes with equal materials are not - * joined. The total number of meshes won't change). - * - * This option could be of use for you if the scene hierarchy contains - * important additional information which you intend to parse. - * For rendering, you can still render all meshes in the scene without - * any transformations. - * Property type: bool. Default value: false. - */ -#define AI_CONFIG_PP_PTV_KEEP_HIERARCHY \ - "PP_PTV_KEEP_HIERARCHY" - -// --------------------------------------------------------------------------- -/** @brief Configures the #aiProcess_PretransformVertices step to normalize - * all vertex components into the -1...1 range. That is, a bounding box - * for the whole scene is computed, the maximum component is taken and all - * meshes are scaled appropriately (uniformly of course!). - * This might be useful if you don't know the spatial dimension of the input - * data*/ -#define AI_CONFIG_PP_PTV_NORMALIZE \ - "PP_PTV_NORMALIZE" - -// --------------------------------------------------------------------------- -/** @brief Configures the #aiProcess_FindDegenerates step to - * remove degenerated primitives from the import - immediately. - * - * The default behaviour converts degenerated triangles to lines and - * degenerated lines to points. See the documentation to the - * #aiProcess_FindDegenerates step for a detailed example of the various ways - * to get rid of these lines and points if you don't want them. - * Property type: bool. Default value: false. - */ -#define AI_CONFIG_PP_FD_REMOVE \ - "PP_FD_REMOVE" - -// --------------------------------------------------------------------------- -/** @brief Configures the #aiProcess_OptimizeGraph step to preserve nodes - * matching a name in a given list. - * - * This is a list of 1 to n strings, ' ' serves as delimiter character. - * Identifiers containing whitespaces must be enclosed in *single* - * quotation marks. For example:<tt> - * "keep-me and_me_to anotherNodeToBeKept \'name with whitespace\'"</tt>. - * If a node matches on of these names, it will not be modified or - * removed by the postprocessing step.<br> - * This option might be useful if you are using some magic node names - * to pass additional semantics through the content pipeline. This ensures - * they won't be optimized away, but a general optimization is still - * performed for nodes not contained in the list. - * Property type: String. Default value: n/a - * @note Linefeeds, tabs or carriage returns are treated as whitespace. - * Node names are case sensitive. - */ -#define AI_CONFIG_PP_OG_EXCLUDE_LIST \ - "PP_OG_EXCLUDE_LIST" - -// --------------------------------------------------------------------------- -/** @brief Set the maximum number of triangles in a mesh. - * - * This is used by the "SplitLargeMeshes" PostProcess-Step to determine - * whether a mesh must be split or not. - * @note The default value is AI_SLM_DEFAULT_MAX_TRIANGLES - * Property type: integer. - */ -#define AI_CONFIG_PP_SLM_TRIANGLE_LIMIT \ - "PP_SLM_TRIANGLE_LIMIT" - -// default value for AI_CONFIG_PP_SLM_TRIANGLE_LIMIT -#if (!defined AI_SLM_DEFAULT_MAX_TRIANGLES) -# define AI_SLM_DEFAULT_MAX_TRIANGLES 1000000 -#endif - -// --------------------------------------------------------------------------- -/** @brief Set the maximum number of vertices in a mesh. - * - * This is used by the "SplitLargeMeshes" PostProcess-Step to determine - * whether a mesh must be split or not. - * @note The default value is AI_SLM_DEFAULT_MAX_VERTICES - * Property type: integer. - */ -#define AI_CONFIG_PP_SLM_VERTEX_LIMIT \ - "PP_SLM_VERTEX_LIMIT" - -// default value for AI_CONFIG_PP_SLM_VERTEX_LIMIT -#if (!defined AI_SLM_DEFAULT_MAX_VERTICES) -# define AI_SLM_DEFAULT_MAX_VERTICES 1000000 -#endif - -// --------------------------------------------------------------------------- -/** @brief Set the maximum number of bones affecting a single vertex - * - * This is used by the #aiProcess_LimitBoneWeights PostProcess-Step. - * @note The default value is AI_LBW_MAX_WEIGHTS - * Property type: integer.*/ -#define AI_CONFIG_PP_LBW_MAX_WEIGHTS \ - "PP_LBW_MAX_WEIGHTS" - -// default value for AI_CONFIG_PP_LBW_MAX_WEIGHTS -#if (!defined AI_LMW_MAX_WEIGHTS) -# define AI_LMW_MAX_WEIGHTS 0x4 -#endif // !! AI_LMW_MAX_WEIGHTS - -/** @brief Default value for the #AI_CONFIG_PP_ICL_PTCACHE_SIZE property - */ -#ifndef PP_ICL_PTCACHE_SIZE -# define PP_ICL_PTCACHE_SIZE 12 -#endif - -// --------------------------------------------------------------------------- -/** @brief Set the size of the post-transform vertex cache to optimize the - * vertices for. This configures the #aiProcess_ImproveCacheLocality step. - * - * The size is given in vertices. Of course you can't know how the vertex - * format will exactly look like after the import returns, but you can still - * guess what your meshes will probably have. - * @note The default value is #PP_ICL_PTCACHE_SIZE. That results in slight - * performance improvements for most nVidia/AMD cards since 2002. - * Property type: integer. - */ -#define AI_CONFIG_PP_ICL_PTCACHE_SIZE "PP_ICL_PTCACHE_SIZE" - -// --------------------------------------------------------------------------- -/** @brief Enumerates components of the aiScene and aiMesh data structures - * that can be excluded from the import using the #aiPrpcess_RemoveComponent step. - * - * See the documentation to #aiProcess_RemoveComponent for more details. - */ -enum aiComponent -{ - /** Normal vectors */ -#ifdef SWIG - aiComponent_NORMALS = 0x2, -#else - aiComponent_NORMALS = 0x2u, -#endif - - /** Tangents and bitangents go always together ... */ -#ifdef SWIG - aiComponent_TANGENTS_AND_BITANGENTS = 0x4, -#else - aiComponent_TANGENTS_AND_BITANGENTS = 0x4u, -#endif - - /** ALL color sets - * Use aiComponent_COLORn(N) to specify the N'th set */ - aiComponent_COLORS = 0x8, - - /** ALL texture UV sets - * aiComponent_TEXCOORDn(N) to specify the N'th set */ - aiComponent_TEXCOORDS = 0x10, - - /** Removes all bone weights from all meshes. - * The scenegraph nodes corresponding to the bones are NOT removed. - * use the #aiProcess_OptimizeGraph step to do this */ - aiComponent_BONEWEIGHTS = 0x20, - - /** Removes all node animations (aiScene::mAnimations). - * The corresponding scenegraph nodes are NOT removed. - * use the #aiProcess_OptimizeGraph step to do this */ - aiComponent_ANIMATIONS = 0x40, - - /** Removes all embedded textures (aiScene::mTextures) */ - aiComponent_TEXTURES = 0x80, - - /** Removes all light sources (aiScene::mLights). - * The corresponding scenegraph nodes are NOT removed. - * use the #aiProcess_OptimizeGraph step to do this */ - aiComponent_LIGHTS = 0x100, - - /** Removes all light sources (aiScene::mCameras). - * The corresponding scenegraph nodes are NOT removed. - * use the #aiProcess_OptimizeGraph step to do this */ - aiComponent_CAMERAS = 0x200, - - /** Removes all meshes (aiScene::mMeshes). */ - aiComponent_MESHES = 0x400, - - /** Removes all materials. One default material will - * be generated, so aiScene::mNumMaterials will be 1. */ - aiComponent_MATERIALS = 0x800, - - - /** This value is not used. It is just there to force the - * compiler to map this enum to a 32 Bit integer. */ -#ifndef SWIG - _aiComponent_Force32Bit = 0x9fffffff -#endif -}; - -// Remove a specific color channel 'n' -#define aiComponent_COLORSn(n) (1u << (n+20u)) - -// Remove a specific UV channel 'n' -#define aiComponent_TEXCOORDSn(n) (1u << (n+25u)) - -// --------------------------------------------------------------------------- -/** @brief Input parameter to the #aiProcess_RemoveComponent step: - * Specifies the parts of the data structure to be removed. - * - * See the documentation to this step for further details. The property - * is expected to be an integer, a bitwise combination of the - * #aiComponent flags defined above in this header. The default - * value is 0. Important: if no valid mesh is remaining after the - * step has been executed (e.g you thought it was funny to specify ALL - * of the flags defined above) the import FAILS. Mainly because there is - * no data to work on anymore ... - */ -#define AI_CONFIG_PP_RVC_FLAGS \ - "PP_RVC_FLAGS" - -// --------------------------------------------------------------------------- -/** @brief Input parameter to the #aiProcess_SortByPType step: - * Specifies which primitive types are removed by the step. - * - * This is a bitwise combination of the aiPrimitiveType flags. - * Specifying all of them is illegal, of course. A typical use would - * be to exclude all line and point meshes from the import. This - * is an integer property, its default value is 0. - */ -#define AI_CONFIG_PP_SBP_REMOVE \ - "PP_SBP_REMOVE" - -// --------------------------------------------------------------------------- -/** @brief Input parameter to the #aiProcess_FindInvalidData step: - * Specifies the floating-point accuracy for animation values. The step - * checks for animation tracks where all frame values are absolutely equal - * and removes them. This tweakable controls the epsilon for floating-point - * comparisons - two keys are considered equal if the invariant - * abs(n0-n1)>epsilon holds true for all vector respectively quaternion - * components. The default value is 0.f - comparisons are exact then. - */ -#define AI_CONFIG_PP_FID_ANIM_ACCURACY \ - "PP_FID_ANIM_ACCURACY" - - -// TransformUVCoords evaluates UV scalings -#define AI_UVTRAFO_SCALING 0x1 - -// TransformUVCoords evaluates UV rotations -#define AI_UVTRAFO_ROTATION 0x2 - -// TransformUVCoords evaluates UV translation -#define AI_UVTRAFO_TRANSLATION 0x4 - -// Everything baked together -> default value -#define AI_UVTRAFO_ALL (AI_UVTRAFO_SCALING | AI_UVTRAFO_ROTATION | AI_UVTRAFO_TRANSLATION) - -// --------------------------------------------------------------------------- -/** @brief Input parameter to the #aiProcess_TransformUVCoords step: - * Specifies which UV transformations are evaluated. - * - * This is a bitwise combination of the AI_UVTRAFO_XXX flags (integer - * property, of course). By default all transformations are enabled - * (AI_UVTRAFO_ALL). - */ -#define AI_CONFIG_PP_TUV_EVALUATE \ - "PP_TUV_EVALUATE" - -// --------------------------------------------------------------------------- -/** @brief A hint to assimp to favour speed against import quality. - * - * Enabling this option may result in faster loading, but it needn't. - * It represents just a hint to loaders and post-processing steps to use - * faster code paths, if possible. - * This property is expected to be an integer, != 0 stands for true. - * The default value is 0. - */ -#define AI_CONFIG_FAVOUR_SPEED \ - "FAVOUR_SPEED" - - -// ########################################################################### -// IMPORTER SETTINGS -// Various stuff to fine-tune the behaviour of specific importer plugins. -// ########################################################################### - - -// --------------------------------------------------------------------------- -/** @brief Set the vertex animation keyframe to be imported - * - * ASSIMP does not support vertex keyframes (only bone animation is supported). - * The library reads only one frame of models with vertex animations. - * By default this is the first frame. - * \note The default value is 0. This option applies to all importers. - * However, it is also possible to override the global setting - * for a specific loader. You can use the AI_CONFIG_IMPORT_XXX_KEYFRAME - * options (where XXX is a placeholder for the file format for which you - * want to override the global setting). - * Property type: integer. - */ -#define AI_CONFIG_IMPORT_GLOBAL_KEYFRAME "IMPORT_GLOBAL_KEYFRAME" - -#define AI_CONFIG_IMPORT_MD3_KEYFRAME "IMPORT_MD3_KEYFRAME" -#define AI_CONFIG_IMPORT_MD2_KEYFRAME "IMPORT_MD2_KEYFRAME" -#define AI_CONFIG_IMPORT_MDL_KEYFRAME "IMPORT_MDL_KEYFRAME" -#define AI_CONFIG_IMPORT_MDC_KEYFRAME "IMPORT_MDC_KEYFRAME" -#define AI_CONFIG_IMPORT_SMD_KEYFRAME "IMPORT_SMD_KEYFRAME" -#define AI_CONFIG_IMPORT_UNREAL_KEYFRAME "IMPORT_UNREAL_KEYFRAME" - - -// --------------------------------------------------------------------------- -/** @brief Configures the AC loader to collect all surfaces which have the - * "Backface cull" flag set in separate meshes. - * - * Property type: bool. Default value: true. - */ -#define AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL \ - "IMPORT_AC_SEPARATE_BFCULL" - -// --------------------------------------------------------------------------- -/** @brief Configures whether the AC loader evaluates subdivision surfaces ( - * indicated by the presence of the 'subdiv' attribute in the file). By - * default, Assimp performs the subdivision using the standard - * Catmull-Clark algorithm - * - * * Property type: bool. Default value: true. - */ -#define AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION \ - "IMPORT_AC_EVAL_SUBDIVISION" - -// --------------------------------------------------------------------------- -/** @brief Configures the UNREAL 3D loader to separate faces with different - * surface flags (e.g. two-sided vs. single-sided). - * - * * Property type: bool. Default value: true. - */ -#define AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS \ - "UNREAL_HANDLE_FLAGS" - -// --------------------------------------------------------------------------- -/** @brief Configures the terragen import plugin to compute uv's for - * terrains, if not given. Furthermore a default texture is assigned. - * - * UV coordinates for terrains are so simple to compute that you'll usually - * want to compute them on your own, if you need them. This option is intended - * for model viewers which want to offer an easy way to apply textures to - * terrains. - * * Property type: bool. Default value: false. - */ -#define AI_CONFIG_IMPORT_TER_MAKE_UVS \ - "IMPORT_TER_MAKE_UVS" - -// --------------------------------------------------------------------------- -/** @brief Configures the ASE loader to always reconstruct normal vectors - * basing on the smoothing groups loaded from the file. - * - * Some ASE files have carry invalid normals, other don't. - * * Property type: bool. Default value: true. - */ -#define AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS \ - "IMPORT_ASE_RECONSTRUCT_NORMALS" - -// --------------------------------------------------------------------------- -/** @brief Configures the M3D loader to detect and process multi-part - * Quake player models. - * - * These models usually consist of 3 files, lower.md3, upper.md3 and - * head.md3. If this property is set to true, Assimp will try to load and - * combine all three files if one of them is loaded. - * Property type: bool. Default value: true. - */ -#define AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART \ - "IMPORT_MD3_HANDLE_MULTIPART" - -// --------------------------------------------------------------------------- -/** @brief Tells the MD3 loader which skin files to load. - * - * When loading MD3 files, Assimp checks whether a file - * <md3_file_name>_<skin_name>.skin is existing. These files are used by - * Quake III to be able to assign different skins (e.g. red and blue team) - * to models. 'default', 'red', 'blue' are typical skin names. - * Property type: String. Default value: "default". - */ -#define AI_CONFIG_IMPORT_MD3_SKIN_NAME \ - "IMPORT_MD3_SKIN_NAME" - -// --------------------------------------------------------------------------- -/** @brief Specify the Quake 3 shader file to be used for a particular - * MD3 file. This can also be a search path. - * - * By default Assimp's behaviour is as follows: If a MD3 file - * <tt><any_path>/models/<any_q3_subdir>/<model_name>/<file_name>.md3</tt> is - * loaded, the library tries to locate the corresponding shader file in - * <tt><any_path>/scripts/<model_name>.shader</tt>. This property overrides this - * behaviour. It can either specify a full path to the shader to be loaded - * or alternatively the path (relative or absolute) to the directory where - * the shaders for all MD3s to be loaded reside. Assimp attempts to open - * <tt><dir>/<model_name>.shader</tt> first, <tt><dir>/<file_name>.shader</tt> - * is the fallback file. Note that <dir> should have a terminal (back)slash. - * Property type: String. Default value: n/a. - */ -#define AI_CONFIG_IMPORT_MD3_SHADER_SRC \ - "IMPORT_MD3_SHADER_SRC" - -// --------------------------------------------------------------------------- -/** @brief Configures the LWO loader to load just one layer from the model. - * - * LWO files consist of layers and in some cases it could be useful to load - * only one of them. This property can be either a string - which specifies - * the name of the layer - or an integer - the index of the layer. If the - * property is not set the whole LWO model is loaded. Loading fails if the - * requested layer is not available. The layer index is zero-based and the - * layer name may not be empty.<br> - * Property type: Integer. Default value: all layers are loaded. - */ -#define AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY \ - "IMPORT_LWO_ONE_LAYER_ONLY" - -// --------------------------------------------------------------------------- -/** @brief Configures the MD5 loader to not load the MD5ANIM file for - * a MD5MESH file automatically. - * - * The default strategy is to look for a file with the same name but the - * MD5ANIM extension in the same directory. If it is found, it is loaded - * and combined with the MD5MESH file. This configuration option can be - * used to disable this behaviour. - * - * * Property type: bool. Default value: false. - */ -#define AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD \ - "IMPORT_MD5_NO_ANIM_AUTOLOAD" - -// --------------------------------------------------------------------------- -/** @brief Defines the begin of the time range for which the LWS loader - * evaluates animations and computes aiNodeAnim's. - * - * Assimp provides full conversion of LightWave's envelope system, including - * pre and post conditions. The loader computes linearly subsampled animation - * chanels with the frame rate given in the LWS file. This property defines - * the start time. Note: animation channels are only generated if a node - * has at least one envelope with more tan one key assigned. This property. - * is given in frames, '0' is the first frame. By default, if this property - * is not set, the importer takes the animation start from the input LWS - * file ('FirstFrame' line)<br> - * Property type: Integer. Default value: taken from file. - * - * @see AI_CONFIG_IMPORT_LWS_ANIM_END - end of the imported time range - */ -#define AI_CONFIG_IMPORT_LWS_ANIM_START \ - "IMPORT_LWS_ANIM_START" -#define AI_CONFIG_IMPORT_LWS_ANIM_END \ - "IMPORT_LWS_ANIM_END" - -// --------------------------------------------------------------------------- -/** @brief Defines the output frame rate of the IRR loader. - * - * IRR animations are difficult to convert for Assimp and there will - * always be a loss of quality. This setting defines how many keys per second - * are returned by the converter.<br> - * Property type: integer. Default value: 100 - */ -#define AI_CONFIG_IMPORT_IRR_ANIM_FPS \ - "IMPORT_IRR_ANIM_FPS" - - -// --------------------------------------------------------------------------- -/** Ogre Importer will try to load this Materialfile - * Ogre Mehs contain only the MaterialName, not the MaterialFile. If there - * is no material file with the same name as the material, Ogre Importer will - * try to load this file and search the material in it. - */ -#define AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE "IMPORT_OGRE_MATERIAL_FILE" - - -#endif // !! AI_CONFIG_H_INC diff --git a/3rdparty/assimp/include/aiDefines.h b/3rdparty/assimp/include/aiDefines.h deleted file mode 100644 index b6c5ff9c..00000000 --- a/3rdparty/assimp/include/aiDefines.h +++ /dev/null @@ -1,279 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiDefines.h - * @brief Assimp build configuration setup. See the notes in the comment - * blocks to find out how to customize _your_ Assimp build. - */ - -#ifndef INCLUDED_AI_DEFINES_H -#define INCLUDED_AI_DEFINES_H - - ////////////////////////////////////////////////////////////////////////// - /* Define ASSIMP_BUILD_NO_XX_IMPORTER to disable a specific - * file format loader. The loader is be excluded from the - * build in this case. 'XX' stands for the most common file - * extension of the file format. E.g.: - * ASSIMP_BUILD_NO_X_IMPORTER disables the X loader. - * - * 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 - * first lines of the corresponding unit. - * - * Other (mixed) configuration switches are listed here: - * ASSIMP_BUILD_NO_COMPRESSED_X - * - Disable support for compressed X files - * ASSIMP_BUILD_NO_COMPRESSED_BLEND - * - Disable support for compressed Blender files*/ - ////////////////////////////////////////////////////////////////////////// - -#ifndef ASSIMP_BUILD_NO_COMPRESSED_X -# define ASSIMP_BUILD_NEED_Z_INFLATE -#endif - -#ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND -# define ASSIMP_BUILD_NEED_Z_INFLATE -#endif - - ////////////////////////////////////////////////////////////////////////// - /* Define ASSIMP_BUILD_NO_XX_PROCESS to disable a specific - * post processing step. This is the current list of process names ('XX'): - * CALCTANGENTS - * JOINVERTICES - * TRIANGULATE - * GENFACENORMALS - * GENVERTEXNORMALS - * REMOVEVC - * SPLITLARGEMESHES - * PRETRANSFORMVERTICES - * LIMITBONEWEIGHTS - * VALIDATEDS - * IMPROVECACHELOCALITY - * FIXINFACINGNORMALS - * REMOVE_REDUNDANTMATERIALS - * OPTIMIZEGRAPH - * SORTBYPTYPE - * FINDINVALIDDATA - * TRANSFORMTEXCOORDS - * GENUVCOORDS - * ENTITYMESHBUILDER - * MAKELEFTHANDED - * FLIPUVS - * FLIPWINDINGORDER - * OPTIMIZEMESHES - * OPTIMIZEANIMS - * OPTIMIZEGRAPH - * GENENTITYMESHES - * FIXTEXTUREPATHS */ - ////////////////////////////////////////////////////////////////////////// - -#ifdef _MSC_VER -# undef ASSIMP_API - - ////////////////////////////////////////////////////////////////////////// - /* Define 'ASSIMP_BUILD_DLL_EXPORT' to build a DLL of the library */ - ////////////////////////////////////////////////////////////////////////// -# ifdef ASSIMP_BUILD_DLL_EXPORT -# define ASSIMP_API __declspec(dllexport) -# pragma warning (disable : 4251) - - ////////////////////////////////////////////////////////////////////////// - /* Define 'ASSIMP_DLL' before including Assimp to link to ASSIMP in - * an external DLL under Windows. Default is static linkage. */ - ////////////////////////////////////////////////////////////////////////// -# elif (defined ASSIMP_DLL) -# define ASSIMP_API __declspec(dllimport) -# else -# define ASSIMP_API -# endif - - /* Force the compiler to inline a function, if possible - */ -# define AI_FORCE_INLINE __forceinline - - /* Tells the compiler that a function never returns. Used in code analysis - * to skip dead paths (e.g. after an assertion evaluated to false). */ -# define AI_WONT_RETURN __declspec(noreturn) -#else - -# define AI_WONT_RETURN - -# define ASSIMP_API -# define AI_FORCE_INLINE inline -#endif // (defined _MSC_VER) - -#ifdef __cplusplus - /* No explicit 'struct' and 'enum' tags for C++, we don't want to - * confuse the _AI_ of our IDE. - */ -# define C_STRUCT -# define C_ENUM -#else - ////////////////////////////////////////////////////////////////////////// - /* To build the documentation, make sure ASSIMP_DOXYGEN_BUILD - * is defined by Doxygen's preprocessor. The corresponding - * entries in the DOXYFILE are: */ - ////////////////////////////////////////////////////////////////////////// -#if 0 - ENABLE_PREPROCESSING = YES - MACRO_EXPANSION = YES - EXPAND_ONLY_PREDEF = YES - SEARCH_INCLUDES = YES - INCLUDE_PATH = - INCLUDE_FILE_PATTERNS = - PREDEFINED = ASSIMP_DOXYGEN_BUILD=1 - EXPAND_AS_DEFINED = C_STRUCT C_ENUM - SKIP_FUNCTION_MACROS = YES -#endif - ////////////////////////////////////////////////////////////////////////// - /* Doxygen gets confused if we use c-struct typedefs to avoid - * the explicit 'struct' notation. This trick here has the same - * effect as the TYPEDEF_HIDES_STRUCT option, but we don't need - * to typedef all structs/enums. */ - ////////////////////////////////////////////////////////////////////////// -# if (defined ASSIMP_DOXYGEN_BUILD) -# define C_STRUCT -# define C_ENUM -# else -# define C_STRUCT struct -# define C_ENUM enum -# endif -#endif - -#if (defined(__BORLANDC__) || defined (__BCPLUSPLUS__)) -#error Currently, Borland is unsupported. Feel free to port Assimp. - -// "W8059 Packgre der Struktur gendert" - -#endif - ////////////////////////////////////////////////////////////////////////// - /* Define 'ASSIMP_BUILD_BOOST_WORKAROUND' to compile assimp - * without boost. This is done by using a few workaround - * classes and brings some limitations (e.g. some logging won't be done, - * the library won't utilize threads or be threadsafe at all). - * This implies the 'ASSIMP_BUILD_SINGLETHREADED' setting. */ - ////////////////////////////////////////////////////////////////////////// -#ifdef ASSIMP_BUILD_BOOST_WORKAROUND - - // threading support requires boost -#ifndef ASSIMP_BUILD_SINGLETHREADED -# define ASSIMP_BUILD_SINGLETHREADED -#endif - -#endif // !! ASSIMP_BUILD_BOOST_WORKAROUND - - ////////////////////////////////////////////////////////////////////////// - /* Define ASSIMP_BUILD_SINGLETHREADED to compile assimp - * without threading support. The library doesn't utilize - * threads then and is itself not threadsafe. - * If this flag is specified boost::threads is *not* required. */ - ////////////////////////////////////////////////////////////////////////// -#ifndef ASSIMP_BUILD_SINGLETHREADED -# define ASSIMP_BUILD_SINGLETHREADED -#endif - -#ifndef ASSIMP_BUILD_SINGLETHREADED -# define AI_C_THREADSAFE -#endif // !! ASSIMP_BUILD_SINGLETHREADED - -#if (defined _DEBUG || defined DEBUG) // one of the two should be defined .. -# define ASSIMP_BUILD_DEBUG -#endif - - ////////////////////////////////////////////////////////////////////////// - /* ASSIMP_BUILD_XXXX_NNBIT_ARCHITECTURE */ - ////////////////////////////////////////////////////////////////////////// -#if defined(_MSC_VER) - // See http://msdn.microsoft.com/en-us/library/b0084kay. -# if defined(_M_IX86) -# define ASSIMP_BUILD_X86_32BIT_ARCHITECTURE -# elif defined(_M_X64) -# define ASSIMP_BUILD_X86_64BIT_ARCHITECTURE -# elif defined(_M_IA64) -# define ASSIMP_BUILD_IA_64BIT_ARCHITECTURE -# else -# error unknown architecture -# endif -#elif defined(__GNUC__) - // See http://gcc.gnu.org/onlinedocs/cpp/Predefined-Macros.html. -# if defined(__x86_32__) || defined(__i386__) -# define ASSIMP_BUILD_X86_32BIT_ARCHITECTURE -# elif defined(__x86_64__) -# define ASSIMP_BUILD_X86_64BIT_ARCHITECTURE -# elif defined(__ppc__) -# define ASSIMP_BUILD_PPC_32BIT_ARCHITECTURE -# elif defined(__arm__) -# define ASSIMP_BUILD_ARM_32BIT_ARCHITECTURE -# else -# error unknown architecture -# endif -#elif defined (__GCCE__) -#define ASSIMP_BUILD_ARM_32BIT_ARCHITECTURE -#elif defined (__arm__) -#define ASSIMP_BUILD_ARM_32BIT_ARCHITECTURE -#else //assume -# error unknown compiler -#endif - - ////////////////////////////////////////////////////////////////////////// - /* Useful constants */ - ////////////////////////////////////////////////////////////////////////// - -/* This is PI. Hi PI. */ -#define AI_MATH_PI (3.141592653589793238462643383279 ) -#define AI_MATH_TWO_PI (AI_MATH_PI * 2.0) -#define AI_MATH_HALF_PI (AI_MATH_PI * 0.5) - -/* And this is to avoid endless casts to float */ -#define AI_MATH_PI_F (3.1415926538f) -#define AI_MATH_TWO_PI_F (AI_MATH_PI_F * 2.0f) -#define AI_MATH_HALF_PI_F (AI_MATH_PI_F * 0.5f) - -/* Tiny macro to convert from radians to degrees and back */ -#define AI_DEG_TO_RAD(x) (x*0.0174532925f) -#define AI_RAD_TO_DEG(x) (x*57.2957795f) - -/* Support for big-endian builds on Mac OS X. */ -#if defined(__APPLE__) && defined(__BIG_ENDIAN__) -#define AI_BUILD_BIG_ENDIAN -#endif - -#endif // !! INCLUDED_AI_DEFINES_H diff --git a/3rdparty/assimp/include/aiFileIO.h b/3rdparty/assimp/include/aiFileIO.h deleted file mode 100644 index bc012fde..00000000 --- a/3rdparty/assimp/include/aiFileIO.h +++ /dev/null @@ -1,135 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiFileIO.h - * @brief Defines generic C routines to access memory-mapped files - */ -#ifndef AI_FILEIO_H_INC -#define AI_FILEIO_H_INC - -#include "aiTypes.h" -#ifdef __cplusplus -extern "C" { -#endif -struct aiFileIO; -struct aiFile; - -// aiFile callbacks -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 (*aiFileTellProc) (C_STRUCT aiFile*); -typedef void (*aiFileFlushProc) (C_STRUCT aiFile*); -typedef aiReturn (*aiFileSeek)(C_STRUCT aiFile*, size_t, aiOrigin); - -// aiFileIO callbacks -typedef aiFile* (*aiFileOpenProc) (C_STRUCT aiFileIO*, const char*, const char*); -typedef void (*aiFileCloseProc) (C_STRUCT aiFileIO*, C_STRUCT aiFile*); - -// Represents user-defined data -typedef char* aiUserData; - -// ---------------------------------------------------------------------------------- -/** @brief C-API: File system callbacks - * - * 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 - * file systems to enable reading from other sources, such as ZIPs - * or memory locations. */ -struct aiFileIO -{ - /** Function used to open a new file - */ - aiFileOpenProc OpenProc; - - /** Function used to close an existing file - */ - aiFileCloseProc CloseProc; - - /** User-defined, opaque data */ - aiUserData UserData; -}; - -// ---------------------------------------------------------------------------------- -/** @brief C-API: File callbacks - * - * Actually, it's a data structure to wrap a set of fXXXX (e.g fopen) - * replacement functions. - * - * The default implementation of the functions utilizes the fXXX functions from - * the CRT. However, you can supply a custom implementation to Assimp by - * delivering a custom aiFileIO. Use this to enable reading from other sources, - * such as ZIP archives or memory locations. */ -struct aiFile -{ - /** Callback to read from a file */ - aiFileReadProc ReadProc; - - /** Callback to write to a file */ - aiFileWriteProc WriteProc; - - /** Callback to retrieve the current position of - * the file cursor (ftell()) - */ - aiFileTellProc TellProc; - - /** Callback to retrieve the size of the file, - * in bytes - */ - aiFileTellProc FileSizeProc; - - /** Callback to set the current position - * of the file cursor (fseek()) - */ - aiFileSeek SeekProc; - - /** Callback to flush the file contents - */ - aiFileFlushProc FlushProc; - - /** User-defined, opaque data - */ - aiUserData UserData; -}; - -#ifdef __cplusplus -} -#endif -#endif // AI_FILEIO_H_INC diff --git a/3rdparty/assimp/include/aiLight.h b/3rdparty/assimp/include/aiLight.h deleted file mode 100644 index 9d1ab10e..00000000 --- a/3rdparty/assimp/include/aiLight.h +++ /dev/null @@ -1,233 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiLight.h - * @brief Defines the aiLight data structure - */ - -#ifndef __AI_LIGHT_H_INC__ -#define __AI_LIGHT_H_INC__ - -#include "aiTypes.h" - -#ifdef __cplusplus -extern "C" { -#endif - -// --------------------------------------------------------------------------- -/** Enumerates all supported types of light sources. - */ -enum aiLightSourceType -{ - aiLightSource_UNDEFINED = 0x0, - - //! A directional light source has a well-defined direction - //! but is infinitely far away. That's quite a good - //! approximation for sun light. - aiLightSource_DIRECTIONAL = 0x1, - - //! A point light source has a well-defined position - //! in space but no direction - it emits light in all - //! directions. A normal bulb is a point light. - aiLightSource_POINT = 0x2, - - //! A spot light source emits light in a specific - //! angle. It has a position and a direction it is pointing to. - //! A good example for a spot light is a light spot in - //! sport arenas. - aiLightSource_SPOT = 0x3, - - - /** This value is not used. It is just there to force the - * compiler to map this enum to a 32 Bit integer. - */ -#ifndef SWIG - _aiLightSource_Force32Bit = 0x9fffffff -#endif -}; - -// --------------------------------------------------------------------------- -/** Helper structure to describe a light source. - * - * Assimp supports multiple sorts of light sources, including - * directional, point and spot lights. All of them are defined with just - * a single structure and distinguished by their parameters. - * 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 - * writes the target point as a subnode of a spotlights's main node, - * called "<spotName>.Target". However, this is just additional information - * then, the transformation tracks of the main node make the - * spot light already point in the right direction. -*/ -struct aiLight -{ - /** The name of the light source. - * - * There must be a node in the scenegraph with the same name. - * This node specifies the position of the light in the scene - * hierarchy and can be animated. - */ - C_STRUCT aiString mName; - - /** The type of the light source. - * - * aiLightSource_UNDEFINED is not a valid value for this member. - */ - C_ENUM aiLightSourceType mType; - - /** Position of the light source in space. Relative to the - * transformation of the node corresponding to the light. - * - * The position is undefined for directional lights. - */ - C_STRUCT aiVector3D mPosition; - - /** Direction of the light source in space. Relative to the - * transformation of the node corresponding to the light. - * - * The direction is undefined for point lights. The vector - * may be normalized, but it needn't. - */ - C_STRUCT aiVector3D mDirection; - - /** Constant light attenuation factor. - * - * The intensity of the light source at a given distance 'd' from - * the light's position is - * @code - * Atten = 1/( att0 + att1 * d + att2 * d*d) - * @endcode - * This member corresponds to the att0 variable in the equation. - * Naturally undefined for directional lights. - */ - float mAttenuationConstant; - - /** Linear light attenuation factor. - * - * The intensity of the light source at a given distance 'd' from - * the light's position is - * @code - * Atten = 1/( att0 + att1 * d + att2 * d*d) - * @endcode - * This member corresponds to the att1 variable in the equation. - * Naturally undefined for directional lights. - */ - float mAttenuationLinear; - - /** Quadratic light attenuation factor. - * - * The intensity of the light source at a given distance 'd' from - * the light's position is - * @code - * Atten = 1/( att0 + att1 * d + att2 * d*d) - * @endcode - * This member corresponds to the att2 variable in the equation. - * Naturally undefined for directional lights. - */ - float mAttenuationQuadratic; - - /** Diffuse color of the light source - * - * The diffuse light color is multiplied with the diffuse - * material color to obtain the final color that contributes - * to the diffuse shading term. - */ - C_STRUCT aiColor3D mColorDiffuse; - - /** Specular color of the light source - * - * The specular light color is multiplied with the specular - * material color to obtain the final color that contributes - * to the specular shading term. - */ - C_STRUCT aiColor3D mColorSpecular; - - /** Ambient color of the light source - * - * The ambient light color is multiplied with the ambient - * material color to obtain the final color that contributes - * to the ambient shading term. Most renderers will ignore - * this value it, is just a remaining of the fixed-function pipeline - * that is still supported by quite many file formats. - */ - C_STRUCT aiColor3D mColorAmbient; - - /** Inner angle of a spot light's light cone. - * - * The spot light has maximum influence on objects inside this - * angle. The angle is given in radians. It is 2PI for point - * lights and undefined for directional lights. - */ - float mAngleInnerCone; - - /** Outer angle of a spot light's light cone. - * - * The spot light does not affect objects outside this angle. - * The angle is given in radians. It is 2PI for point lights and - * undefined for directional lights. The outer angle must be - * greater than or equal to the inner angle. - * It is assumed that the application uses a smooth - * interpolation between the inner and the outer cone of the - * spot light. - */ - float mAngleOuterCone; - -#ifdef __cplusplus - - aiLight() - : mType (aiLightSource_UNDEFINED) - , mAttenuationConstant (0.f) - , mAttenuationLinear (1.f) - , mAttenuationQuadratic (0.f) - , mAngleInnerCone ((float)AI_MATH_TWO_PI) - , mAngleOuterCone ((float)AI_MATH_TWO_PI) - { - } - -#endif -}; - -#ifdef __cplusplus -} -#endif - - -#endif // !! __AI_LIGHT_H_INC__ diff --git a/3rdparty/assimp/include/aiMaterial.h b/3rdparty/assimp/include/aiMaterial.h deleted file mode 100644 index 34914d23..00000000 --- a/3rdparty/assimp/include/aiMaterial.h +++ /dev/null @@ -1,1422 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiMaterial.h - * @brief Defines the material system of the library - */ - -#ifndef AI_MATERIAL_H_INC -#define AI_MATERIAL_H_INC - -#include "aiTypes.h" - -#ifdef __cplusplus -extern "C" { -#endif - -// Name for default materials (2nd is used if meshes have UV coords) -#define AI_DEFAULT_MATERIAL_NAME "DefaultMaterial" -#define AI_DEFAULT_TEXTURED_MATERIAL_NAME "TexturedDefaultMaterial" - -// --------------------------------------------------------------------------- -/** @brief Defines how the Nth texture of a specific type is combined with - * the result of all previous layers. - * - * Example (left: key, right: value): <br> - * @code - * DiffColor0 - gray - * DiffTextureOp0 - aiTextureOpMultiply - * DiffTexture0 - tex1.png - * DiffTextureOp0 - aiTextureOpAdd - * DiffTexture1 - tex2.png - * @endcode - * Written as equation, the final diffuse term for a specific pixel would be: - * @code - * diffFinal = DiffColor0 * sampleTex(DiffTexture0,UV0) + - * sampleTex(DiffTexture1,UV0) * diffContrib; - * @endcode - * where 'diffContrib' is the intensity of the incoming light for that pixel. - */ -enum aiTextureOp -{ - /** T = T1 * T2 */ - aiTextureOp_Multiply = 0x0, - - /** T = T1 + T2 */ - aiTextureOp_Add = 0x1, - - /** T = T1 - T2 */ - aiTextureOp_Subtract = 0x2, - - /** T = T1 / T2 */ - aiTextureOp_Divide = 0x3, - - /** T = (T1 + T2) - (T1 * T2) */ - aiTextureOp_SmoothAdd = 0x4, - - /** T = T1 + (T2-0.5) */ - aiTextureOp_SignedAdd = 0x5, - - - /** @cond never - * This value is not used. It forces the compiler to use at least - * 32 Bit integers to represent this enum. - */ -#ifndef SWIG - _aiTextureOp_Force32Bit = 0x9fffffff -#endif - //! @endcond -}; - -// --------------------------------------------------------------------------- -/** @brief Defines how UV coordinates outside the [0...1] range are handled. - * - * Commonly refered to as 'wrapping mode'. - */ -enum aiTextureMapMode -{ - /** A texture coordinate u|v is translated to u%1|v%1 - */ - aiTextureMapMode_Wrap = 0x0, - - /** Texture coordinates outside [0...1] - * are clamped to the nearest valid value. - */ - aiTextureMapMode_Clamp = 0x1, - - /** If the texture coordinates for a pixel are outside [0...1] - * the texture is not applied to that pixel - */ - aiTextureMapMode_Decal = 0x3, - - /** A texture coordinate u|v becomes u%1|v%1 if (u-(u%1))%2 is zero and - * 1-(u%1)|1-(v%1) otherwise - */ - aiTextureMapMode_Mirror = 0x2, - - /** @cond never - * This value is not used. It forces the compiler to use at least - * 32 Bit integers to represent this enum. - */ -#ifndef SWIG - _aiTextureMapMode_Force32Bit = 0x9fffffff -#endif - //! @endcond -}; - -// --------------------------------------------------------------------------- -/** @brief Defines how the mapping coords for a texture are generated. - * - * Real-time applications typically require full UV coordinates, so the use of - * the aiProcess_GenUVCoords step is highly recommended. It generates proper - * UV channels for non-UV mapped objects, as long as an accurate description - * how the mapping should look like (e.g spherical) is given. - * See the #AI_MATKEY_MAPPING property for more details. - */ -enum aiTextureMapping -{ - /** The mapping coordinates are taken from an UV channel. - * - * The #AI_MATKEY_UVWSRC key specifies from which UV channel - * the texture coordinates are to be taken from (remember, - * meshes can have more than one UV channel). - */ - aiTextureMapping_UV = 0x0, - - /** Spherical mapping */ - aiTextureMapping_SPHERE = 0x1, - - /** Cylindrical mapping */ - aiTextureMapping_CYLINDER = 0x2, - - /** Cubic mapping */ - aiTextureMapping_BOX = 0x3, - - /** Planar mapping */ - aiTextureMapping_PLANE = 0x4, - - /** Undefined mapping. Have fun. */ - aiTextureMapping_OTHER = 0x5, - - - /** @cond never - * This value is not used. It forces the compiler to use at least - * 32 Bit integers to represent this enum. - */ -#ifndef SWIG - _aiTextureMapping_Force32Bit = 0x9fffffff -#endif - //! @endcond -}; - -// --------------------------------------------------------------------------- -/** @brief Defines the purpose of a texture - * - * This is a very difficult topic. Different 3D packages support different - * kinds of textures. For very common texture types, such as bumpmaps, the - * rendering results depend on implementation details in the rendering - * pipelines of these applications. Assimp loads all texture references from - * the model file and tries to determine which of the predefined texture - * types below is the best choice to match the original use of the texture - * as closely as possible.<br> - * - * In content pipelines you'll usually define how textures have to be handled, - * and the artists working on models have to conform to this specification, - * regardless which 3D tool they're using. - */ -enum aiTextureType -{ - /** Dummy value. - * - * No texture, but the value to be used as 'texture semantic' - * (#aiMaterialProperty::mSemantic) for all material properties - * *not* related to textures. - */ - aiTextureType_NONE = 0x0, - - - - /** The texture is combined with the result of the diffuse - * lighting equation. - */ - aiTextureType_DIFFUSE = 0x1, - - /** The texture is combined with the result of the specular - * lighting equation. - */ - aiTextureType_SPECULAR = 0x2, - - /** The texture is combined with the result of the ambient - * lighting equation. - */ - aiTextureType_AMBIENT = 0x3, - - /** The texture is added to the result of the lighting - * calculation. It isn't influenced by incoming light. - */ - aiTextureType_EMISSIVE = 0x4, - - /** The texture is a height map. - * - * By convention, higher gray-scale values stand for - * higher elevations from the base height. - */ - aiTextureType_HEIGHT = 0x5, - - /** The texture is a (tangent space) normal-map. - * - * Again, there are several conventions for tangent-space - * normal maps. Assimp does (intentionally) not - * distinguish here. - */ - aiTextureType_NORMALS = 0x6, - - /** The texture defines the glossiness of the material. - * - * The glossiness is in fact the exponent of the specular - * (phong) lighting equation. Usually there is a conversion - * function defined to map the linear color values in the - * texture to a suitable exponent. Have fun. - */ - aiTextureType_SHININESS = 0x7, - - /** The texture defines per-pixel opacity. - * - * Usually 'white' means opaque and 'black' means - * 'transparency'. Or quite the opposite. Have fun. - */ - aiTextureType_OPACITY = 0x8, - - /** Displacement texture - * - * The exact purpose and format is application-dependent. - * Higher color values stand for higher vertex displacements. - */ - aiTextureType_DISPLACEMENT = 0x9, - - /** Lightmap texture (aka Ambient Occlusion) - * - * Both 'Lightmaps' and dedicated 'ambient occlusion maps' are - * covered by this material property. The texture contains a - * scaling value for the final color value of a pixel. Its - * intensity is not affected by incoming light. - */ - aiTextureType_LIGHTMAP = 0xA, - - /** Reflection texture - * - * Contains the color of a perfect mirror reflection. - * Rarely used, almost never for real-time applications. - */ - aiTextureType_REFLECTION = 0xB, - - /** Unknown texture - * - * A texture reference that does not match any of the definitions - * above is considered to be 'unknown'. It is still imported, - * but is excluded from any further postprocessing. - */ - aiTextureType_UNKNOWN = 0xC, - - - /** @cond never - * This value is not used. It forces the compiler to use at least - * 32 Bit integers to represent this enum. - */ -#ifndef SWIG - _aiTextureType_Force32Bit = 0x9fffffff -#endif - //! @endcond -}; - -#define AI_TEXTURE_TYPE_MAX aiTextureType_UNKNOWN - -// --------------------------------------------------------------------------- -/** @brief Defines all shading models supported by the library - * - * The list of shading modes has been taken from Blender. - * See Blender documentation for more information. The API does - * not distinguish between "specular" and "diffuse" shaders (thus the - * specular term for diffuse shading models like Oren-Nayar remains - * undefined). <br> - * Again, this value is just a hint. Assimp tries to select the shader whose - * most common implementation matches the original rendering results of the - * 3D modeller which wrote a particular model as closely as possible. - */ -enum aiShadingMode -{ - /** Flat shading. Shading is done on per-face base, - * diffuse only. Also known as 'faceted shading'. - */ - aiShadingMode_Flat = 0x1, - - /** Simple Gouraud shading. - */ - aiShadingMode_Gouraud = 0x2, - - /** Phong-Shading - - */ - aiShadingMode_Phong = 0x3, - - /** Phong-Blinn-Shading - */ - aiShadingMode_Blinn = 0x4, - - /** Toon-Shading per pixel - * - * Also known as 'comic' shader. - */ - aiShadingMode_Toon = 0x5, - - /** OrenNayar-Shading per pixel - * - * Extension to standard Lambertian shading, taking the - * roughness of the material into account - */ - aiShadingMode_OrenNayar = 0x6, - - /** Minnaert-Shading per pixel - * - * Extension to standard Lambertian shading, taking the - * "darkness" of the material into account - */ - aiShadingMode_Minnaert = 0x7, - - /** CookTorrance-Shading per pixel - * - * Special shader for metallic surfaces. - */ - aiShadingMode_CookTorrance = 0x8, - - /** No shading at all. Constant light influence of 1.0. - */ - aiShadingMode_NoShading = 0x9, - - /** Fresnel shading - */ - aiShadingMode_Fresnel = 0xa, - - - /** @cond never - * This value is not used. It forces the compiler to use at least - * 32 Bit integers to represent this enum. - */ -#ifndef SWIG - _aiShadingMode_Force32Bit = 0x9fffffff -#endif - //! @endcond -}; - - -// --------------------------------------------------------------------------- -/** @brief Defines some mixed flags for a particular texture. - * - * Usually you'll instruct your cg artists how textures have to look like ... - * and how they will be processed in your application. However, if you use - * Assimp for completely generic loading purposes you might also need to - * process these flags in order to display as many 'unknown' 3D models as - * possible correctly. - * - * This corresponds to the #AI_MATKEY_TEXFLAGS property. -*/ -enum aiTextureFlags -{ - /** The texture's color values have to be inverted (componentwise 1-n) - */ - aiTextureFlags_Invert = 0x1, - - /** Explicit request to the application to process the alpha channel - * of the texture. - * - * Mutually exclusive with #aiTextureFlags_IgnoreAlpha. These - * flags are set if the library can say for sure that the alpha - * channel is used/is not used. If the model format does not - * define this, it is left to the application to decide whether - * the texture alpha channel - if any - is evaluated or not. - */ - aiTextureFlags_UseAlpha = 0x2, - - /** Explicit request to the application to ignore the alpha channel - * of the texture. - * - * Mutually exclusive with #aiTextureFlags_UseAlpha. - */ - aiTextureFlags_IgnoreAlpha = 0x4, - - /** @cond never - * This value is not used. It forces the compiler to use at least - * 32 Bit integers to represent this enum. - */ -#ifndef SWIG - _aiTextureFlags_Force32Bit = 0x9fffffff -#endif - //! @endcond -}; - - -// --------------------------------------------------------------------------- -/** @brief Defines alpha-blend flags. - * - * If you're familiar with OpenGL or D3D, these flags aren't new to you. - * They define *how* the final color value of a pixel is computed, basing - * on the previous color at that pixel and the new color value from the - * material. - * The blend formula is: - * @code - * SourceColor * SourceBlend + DestColor * DestBlend - * @endcode - * where <DestColor> is the previous color in the framebuffer at this - * position and <SourceColor> is the material colro before the transparency - * calculation.<br> - * This corresponds to the #AI_MATKEY_BLEND_FUNC property. -*/ -enum aiBlendMode -{ - /** - * Formula: - * @code - * SourceColor*SourceAlpha + DestColor*(1-SourceAlpha) - * @endcode - */ - aiBlendMode_Default = 0x0, - - /** Additive blending - * - * Formula: - * @code - * SourceColor*1 + DestColor*1 - * @endcode - */ - aiBlendMode_Additive = 0x1, - - // we don't need more for the moment, but we might need them - // in future versions ... - - /** @cond never - * This value is not used. It forces the compiler to use at least - * 32 Bit integers to represent this enum. - */ -#ifndef SWIG - _aiBlendMode_Force32Bit = 0x9fffffff -#endif - //! @endcond -}; - - -#include "./Compiler/pushpack1.h" - -// --------------------------------------------------------------------------- -/** @brief Defines how an UV channel is transformed. - * - * This is just a helper structure for the #AI_MATKEY_UVTRANSFORM key. - * See its documentation for more details. - * - * Typically you'll want to build a matrix of this information. However, - * we keep separate scaling/translation/rotation values to make it - * easier to process and optimize UV transformations internally. - */ -struct aiUVTransform -{ - /** Translation on the u and v axes. - * - * The default value is (0|0). - */ - C_STRUCT aiVector2D mTranslation; - - /** Scaling on the u and v axes. - * - * The default value is (1|1). - */ - C_STRUCT aiVector2D mScaling; - - /** Rotation - in counter-clockwise direction. - * - * The rotation angle is specified in radians. The - * rotation center is 0.5f|0.5f. The default value - * 0.f. - */ - float mRotation; - - -#ifdef __cplusplus - aiUVTransform() - : mScaling (1.f,1.f) - , mRotation (0.f) - { - // nothing to be done here ... - } -#endif - -} PACK_STRUCT; - -#include "./Compiler/poppack1.h" - -//! @cond AI_DOX_INCLUDE_INTERNAL -// --------------------------------------------------------------------------- -/** @brief A very primitive RTTI system for the contents of material - * properties. - */ -enum aiPropertyTypeInfo -{ - /** Array of single-precision (32 Bit) floats - * - * It is possible to use aiGetMaterialInteger[Array]() (or the C++-API - * aiMaterial::Get()) to query properties stored in floating-point format. - * The material system performs the type conversion automatically. - */ - aiPTI_Float = 0x1, - - /** The material property is an aiString. - * - * Arrays of strings aren't possible, aiGetMaterialString() (or the - * C++-API aiMaterial::Get()) *must* be used to query a string property. - */ - aiPTI_String = 0x3, - - /** Array of (32 Bit) integers - * - * It is possible to use aiGetMaterialFloat[Array]() (or the C++-API - * aiMaterial::Get()) to query properties stored in integer format. - * The material system performs the type conversion automatically. - */ - aiPTI_Integer = 0x4, - - - /** Simple binary buffer, content undefined. Not convertible to anything. - */ - aiPTI_Buffer = 0x5, - - - /** This value is not used. It is just there to force the - * compiler to map this enum to a 32 Bit integer. - */ -#ifndef SWIG - _aiPTI_Force32Bit = 0x9fffffff -#endif -}; - -// --------------------------------------------------------------------------- -/** @brief Data structure for a single material property - * - * As an user, you'll probably never need to deal with this data structure. - * Just use the provided aiGetMaterialXXX() or aiMaterial::Get() family - * of functions to query material properties easily. Processing them - * manually is faster, but it is not the recommended way. It isn't worth - * the effort. <br> - * Material property names follow a simple scheme: - * @code - * $<name> - * ?<name> - * A public property, there must be corresponding AI_MATKEY_XXX define - * 2nd: Public, but ignored by the #aiProcess_RemoveRedundantMaterials - * post-processing step. - * ~<name> - * A temporary property for internal use. - * @endcode - * @see aiMaterial - */ -struct aiMaterialProperty -{ - /** Specifies the name of the property (key) - * Keys are generally case insensitive. - */ - C_STRUCT aiString mKey; - - /** Textures: Specifies their exact usage semantic. - * For non-texture properties, this member is always 0 - * (or, better-said, #aiTextureType_NONE). - */ - unsigned int mSemantic; - - /** Textures: Specifies the index of the texture. - * For non-texture properties, this member is always 0. - */ - unsigned int mIndex; - - /** Size of the buffer mData is pointing to, in bytes. - * This value may not be 0. - */ - unsigned int mDataLength; - - /** Type information for the property. - * - * Defines the data layout inside the data buffer. This is used - * by the library internally to perform debug checks and to - * utilize proper type conversions. - * (It's probably a hacky solution, but it works.) - */ - C_ENUM aiPropertyTypeInfo mType; - - /** Binary buffer to hold the property's value. - * The size of the buffer is always mDataLength. - */ - char* mData; - -#ifdef __cplusplus - - aiMaterialProperty() { - mData = NULL; - mIndex = mSemantic = 0; - } - - ~aiMaterialProperty() { - delete[] mData; - } - -#endif -}; -//! @endcond - -#ifdef __cplusplus -} // We need to leave the "C" block here to allow template member functions -#endif - -// --------------------------------------------------------------------------- -/** @brief Data structure for a material -* -* Material data is stored using a key-value structure. A single key-value -* pair is called a 'material property'. C++ users should use the provided -* member functions of aiMaterial to process material properties, C users -* have to stick with the aiMaterialGetXXX family of unbound functions. -* The library defines a set of standard keys (AI_MATKEY_XXX). -*/ -struct ASSIMP_API aiMaterial -{ - -#ifdef __cplusplus - - /// NOTE: no initialization, instance Assimp::MaterialHelper instead - aiMaterial() {} - -public: - - ~aiMaterial(); - - // ------------------------------------------------------------------- - /** @brief Retrieve an array of Type values with a specific key - * from the material - * - * @param pKey Key to search for. One of the AI_MATKEY_XXX constants. - * @param type .. set by AI_MATKEY_XXX - * @param idx .. set by AI_MATKEY_XXX - * @param pOut Pointer to a buffer to receive the result. - * @param pMax Specifies the size of the given buffer, in Type's. - * Receives the number of values (not bytes!) read. - * NULL is a valid value for this parameter. - */ - template <typename Type> - aiReturn Get(const char* pKey,unsigned int type, - unsigned int idx, Type* pOut, unsigned int* pMax) const; - - // ------------------------------------------------------------------- - /** @brief Retrieve a Type value with a specific key - * from the material - * - * @param pKey Key to search for. One of the AI_MATKEY_XXX constants. - * @param type Specifies the type of the texture to be retrieved ( - * e.g. diffuse, specular, height map ...) - * @param idx Index of the texture to be retrieved. - * @param pOut Reference to receive the output value - */ - template <typename Type> - aiReturn Get(const char* pKey,unsigned int type, - unsigned int idx,Type& pOut) const; - - // ------------------------------------------------------------------- - /** Get the number of textures for a particular texture type. - * @param type Texture type to check for - * @return Number of textures for this type. - * @note A texture can be easily queried using #GetTexture() */ - unsigned int GetTextureCount(aiTextureType type) const; - - // ------------------------------------------------------------------- - /** Helper function to get all parameters pertaining to a - * particular texture slot from a material. - * - * This function is provided just for convenience, you could also - * read the single material properties manually. - * @param type Specifies the type of the texture to be retrieved ( - * e.g. diffuse, specular, height map ...) - * @param index Index of the texture to be retrieved. The function fails - * if there is no texture of that type with this index. - * #GetTextureCount() can be used to determine the number of textures - * per texture type. - * @param path Receives the path to the texture. - * NULL is a valid value. - * @param mapping The texture mapping. - * NULL is allowed as value. - * @param uvindex Receives the UV index of the texture. - * NULL is a valid value. - * @param blend Receives the blend factor for the texture - * NULL is a valid value. - * @param op Receives the texture operation to be performed between - * this texture and the previous texture. NULL is allowed as value. - * @param mapmode Receives the mapping modes to be used for the texture. - * The parameter may be NULL but if it is a valid pointer it MUST - * point to an array of 3 aiTextureMapMode's (one for each - * axis: UVW order (=XYZ)). - */ - // ------------------------------------------------------------------- - aiReturn GetTexture(aiTextureType type, - unsigned int index, - C_STRUCT aiString* path, - aiTextureMapping* mapping = NULL, - unsigned int* uvindex = NULL, - float* blend = NULL, - aiTextureOp* op = NULL, - aiTextureMapMode* mapmode = NULL) const; - -#endif - - /** List of all material properties loaded. */ - C_STRUCT aiMaterialProperty** mProperties; - - /** Number of properties in the data base */ - unsigned int mNumProperties; - - /** Storage allocated */ - unsigned int mNumAllocated; -}; - -// Go back to extern "C" again -#ifdef __cplusplus -extern "C" { -#endif - -// --------------------------------------------------------------------------- -#define AI_MATKEY_NAME "?mat.name",0,0 -#define AI_MATKEY_TWOSIDED "$mat.twosided",0,0 -#define AI_MATKEY_SHADING_MODEL "$mat.shadingm",0,0 -#define AI_MATKEY_ENABLE_WIREFRAME "$mat.wireframe",0,0 -#define AI_MATKEY_BLEND_FUNC "$mat.blend",0,0 -#define AI_MATKEY_OPACITY "$mat.opacity",0,0 -#define AI_MATKEY_BUMPSCALING "$mat.bumpscaling",0,0 -#define AI_MATKEY_SHININESS "$mat.shininess",0,0 -#define AI_MATKEY_REFLECTIVITY "$mat.reflectivity",0,0 -#define AI_MATKEY_SHININESS_STRENGTH "$mat.shinpercent",0,0 -#define AI_MATKEY_REFRACTI "$mat.refracti",0,0 -#define AI_MATKEY_COLOR_DIFFUSE "$clr.diffuse",0,0 -#define AI_MATKEY_COLOR_AMBIENT "$clr.ambient",0,0 -#define AI_MATKEY_COLOR_SPECULAR "$clr.specular",0,0 -#define AI_MATKEY_COLOR_EMISSIVE "$clr.emissive",0,0 -#define AI_MATKEY_COLOR_TRANSPARENT "$clr.transparent",0,0 -#define AI_MATKEY_COLOR_REFLECTIVE "$clr.reflective",0,0 -#define AI_MATKEY_GLOBAL_BACKGROUND_IMAGE "?bg.global",0,0 - -// --------------------------------------------------------------------------- -// Pure key names for all texture-related properties -//! @cond MATS_DOC_FULL -#define _AI_MATKEY_TEXTURE_BASE "$tex.file" -#define _AI_MATKEY_UVWSRC_BASE "$tex.uvwsrc" -#define _AI_MATKEY_TEXOP_BASE "$tex.op" -#define _AI_MATKEY_MAPPING_BASE "$tex.mapping" -#define _AI_MATKEY_TEXBLEND_BASE "$tex.blend" -#define _AI_MATKEY_MAPPINGMODE_U_BASE "$tex.mapmodeu" -#define _AI_MATKEY_MAPPINGMODE_V_BASE "$tex.mapmodev" -#define _AI_MATKEY_TEXMAP_AXIS_BASE "$tex.mapaxis" -#define _AI_MATKEY_UVTRANSFORM_BASE "$tex.uvtrafo" -#define _AI_MATKEY_TEXFLAGS_BASE "$tex.flags" -//! @endcond - -// --------------------------------------------------------------------------- -#define AI_MATKEY_TEXTURE(type, N) _AI_MATKEY_TEXTURE_BASE,type,N - -// For backward compatibility and simplicity -//! @cond MATS_DOC_FULL -#define AI_MATKEY_TEXTURE_DIFFUSE(N) \ - AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE,N) - -#define AI_MATKEY_TEXTURE_SPECULAR(N) \ - AI_MATKEY_TEXTURE(aiTextureType_SPECULAR,N) - -#define AI_MATKEY_TEXTURE_AMBIENT(N) \ - AI_MATKEY_TEXTURE(aiTextureType_AMBIENT,N) - -#define AI_MATKEY_TEXTURE_EMISSIVE(N) \ - AI_MATKEY_TEXTURE(aiTextureType_EMISSIVE,N) - -#define AI_MATKEY_TEXTURE_NORMALS(N) \ - AI_MATKEY_TEXTURE(aiTextureType_NORMALS,N) - -#define AI_MATKEY_TEXTURE_HEIGHT(N) \ - AI_MATKEY_TEXTURE(aiTextureType_HEIGHT,N) - -#define AI_MATKEY_TEXTURE_SHININESS(N) \ - AI_MATKEY_TEXTURE(aiTextureType_SHININESS,N) - -#define AI_MATKEY_TEXTURE_OPACITY(N) \ - AI_MATKEY_TEXTURE(aiTextureType_OPACITY,N) - -#define AI_MATKEY_TEXTURE_DISPLACEMENT(N) \ - AI_MATKEY_TEXTURE(aiTextureType_DISPLACEMENT,N) - -#define AI_MATKEY_TEXTURE_LIGHTMAP(N) \ - AI_MATKEY_TEXTURE(aiTextureType_LIGHTMAP,N) - -#define AI_MATKEY_TEXTURE_REFLECTION(N) \ - AI_MATKEY_TEXTURE(aiTextureType_REFLECTION,N) - -//! @endcond - -// --------------------------------------------------------------------------- -#define AI_MATKEY_UVWSRC(type, N) _AI_MATKEY_UVWSRC_BASE,type,N - -// For backward compatibility and simplicity -//! @cond MATS_DOC_FULL -#define AI_MATKEY_UVWSRC_DIFFUSE(N) \ - AI_MATKEY_UVWSRC(aiTextureType_DIFFUSE,N) - -#define AI_MATKEY_UVWSRC_SPECULAR(N) \ - AI_MATKEY_UVWSRC(aiTextureType_SPECULAR,N) - -#define AI_MATKEY_UVWSRC_AMBIENT(N) \ - AI_MATKEY_UVWSRC(aiTextureType_AMBIENT,N) - -#define AI_MATKEY_UVWSRC_EMISSIVE(N) \ - AI_MATKEY_UVWSRC(aiTextureType_EMISSIVE,N) - -#define AI_MATKEY_UVWSRC_NORMALS(N) \ - AI_MATKEY_UVWSRC(aiTextureType_NORMALS,N) - -#define AI_MATKEY_UVWSRC_HEIGHT(N) \ - AI_MATKEY_UVWSRC(aiTextureType_HEIGHT,N) - -#define AI_MATKEY_UVWSRC_SHININESS(N) \ - AI_MATKEY_UVWSRC(aiTextureType_SHININESS,N) - -#define AI_MATKEY_UVWSRC_OPACITY(N) \ - AI_MATKEY_UVWSRC(aiTextureType_OPACITY,N) - -#define AI_MATKEY_UVWSRC_DISPLACEMENT(N) \ - AI_MATKEY_UVWSRC(aiTextureType_DISPLACEMENT,N) - -#define AI_MATKEY_UVWSRC_LIGHTMAP(N) \ - AI_MATKEY_UVWSRC(aiTextureType_LIGHTMAP,N) - -#define AI_MATKEY_UVWSRC_REFLECTION(N) \ - AI_MATKEY_UVWSRC(aiTextureType_REFLECTION,N) - -//! @endcond -// --------------------------------------------------------------------------- -#define AI_MATKEY_TEXOP(type, N) _AI_MATKEY_TEXOP_BASE,type,N - -// For backward compatibility and simplicity -//! @cond MATS_DOC_FULL -#define AI_MATKEY_TEXOP_DIFFUSE(N) \ - AI_MATKEY_TEXOP(aiTextureType_DIFFUSE,N) - -#define AI_MATKEY_TEXOP_SPECULAR(N) \ - AI_MATKEY_TEXOP(aiTextureType_SPECULAR,N) - -#define AI_MATKEY_TEXOP_AMBIENT(N) \ - AI_MATKEY_TEXOP(aiTextureType_AMBIENT,N) - -#define AI_MATKEY_TEXOP_EMISSIVE(N) \ - AI_MATKEY_TEXOP(aiTextureType_EMISSIVE,N) - -#define AI_MATKEY_TEXOP_NORMALS(N) \ - AI_MATKEY_TEXOP(aiTextureType_NORMALS,N) - -#define AI_MATKEY_TEXOP_HEIGHT(N) \ - AI_MATKEY_TEXOP(aiTextureType_HEIGHT,N) - -#define AI_MATKEY_TEXOP_SHININESS(N) \ - AI_MATKEY_TEXOP(aiTextureType_SHININESS,N) - -#define AI_MATKEY_TEXOP_OPACITY(N) \ - AI_MATKEY_TEXOP(aiTextureType_OPACITY,N) - -#define AI_MATKEY_TEXOP_DISPLACEMENT(N) \ - AI_MATKEY_TEXOP(aiTextureType_DISPLACEMENT,N) - -#define AI_MATKEY_TEXOP_LIGHTMAP(N) \ - AI_MATKEY_TEXOP(aiTextureType_LIGHTMAP,N) - -#define AI_MATKEY_TEXOP_REFLECTION(N) \ - AI_MATKEY_TEXOP(aiTextureType_REFLECTION,N) - -//! @endcond -// --------------------------------------------------------------------------- -#define AI_MATKEY_MAPPING(type, N) _AI_MATKEY_MAPPING_BASE,type,N - -// For backward compatibility and simplicity -//! @cond MATS_DOC_FULL -#define AI_MATKEY_MAPPING_DIFFUSE(N) \ - AI_MATKEY_MAPPING(aiTextureType_DIFFUSE,N) - -#define AI_MATKEY_MAPPING_SPECULAR(N) \ - AI_MATKEY_MAPPING(aiTextureType_SPECULAR,N) - -#define AI_MATKEY_MAPPING_AMBIENT(N) \ - AI_MATKEY_MAPPING(aiTextureType_AMBIENT,N) - -#define AI_MATKEY_MAPPING_EMISSIVE(N) \ - AI_MATKEY_MAPPING(aiTextureType_EMISSIVE,N) - -#define AI_MATKEY_MAPPING_NORMALS(N) \ - AI_MATKEY_MAPPING(aiTextureType_NORMALS,N) - -#define AI_MATKEY_MAPPING_HEIGHT(N) \ - AI_MATKEY_MAPPING(aiTextureType_HEIGHT,N) - -#define AI_MATKEY_MAPPING_SHININESS(N) \ - AI_MATKEY_MAPPING(aiTextureType_SHININESS,N) - -#define AI_MATKEY_MAPPING_OPACITY(N) \ - AI_MATKEY_MAPPING(aiTextureType_OPACITY,N) - -#define AI_MATKEY_MAPPING_DISPLACEMENT(N) \ - AI_MATKEY_MAPPING(aiTextureType_DISPLACEMENT,N) - -#define AI_MATKEY_MAPPING_LIGHTMAP(N) \ - AI_MATKEY_MAPPING(aiTextureType_LIGHTMAP,N) - -#define AI_MATKEY_MAPPING_REFLECTION(N) \ - AI_MATKEY_MAPPING(aiTextureType_REFLECTION,N) - -//! @endcond -// --------------------------------------------------------------------------- -#define AI_MATKEY_TEXBLEND(type, N) _AI_MATKEY_TEXBLEND_BASE,type,N - -// For backward compatibility and simplicity -//! @cond MATS_DOC_FULL -#define AI_MATKEY_TEXBLEND_DIFFUSE(N) \ - AI_MATKEY_TEXBLEND(aiTextureType_DIFFUSE,N) - -#define AI_MATKEY_TEXBLEND_SPECULAR(N) \ - AI_MATKEY_TEXBLEND(aiTextureType_SPECULAR,N) - -#define AI_MATKEY_TEXBLEND_AMBIENT(N) \ - AI_MATKEY_TEXBLEND(aiTextureType_AMBIENT,N) - -#define AI_MATKEY_TEXBLEND_EMISSIVE(N) \ - AI_MATKEY_TEXBLEND(aiTextureType_EMISSIVE,N) - -#define AI_MATKEY_TEXBLEND_NORMALS(N) \ - AI_MATKEY_TEXBLEND(aiTextureType_NORMALS,N) - -#define AI_MATKEY_TEXBLEND_HEIGHT(N) \ - AI_MATKEY_TEXBLEND(aiTextureType_HEIGHT,N) - -#define AI_MATKEY_TEXBLEND_SHININESS(N) \ - AI_MATKEY_TEXBLEND(aiTextureType_SHININESS,N) - -#define AI_MATKEY_TEXBLEND_OPACITY(N) \ - AI_MATKEY_TEXBLEND(aiTextureType_OPACITY,N) - -#define AI_MATKEY_TEXBLEND_DISPLACEMENT(N) \ - AI_MATKEY_TEXBLEND(aiTextureType_DISPLACEMENT,N) - -#define AI_MATKEY_TEXBLEND_LIGHTMAP(N) \ - AI_MATKEY_TEXBLEND(aiTextureType_LIGHTMAP,N) - -#define AI_MATKEY_TEXBLEND_REFLECTION(N) \ - AI_MATKEY_TEXBLEND(aiTextureType_REFLECTION,N) - -//! @endcond -// --------------------------------------------------------------------------- -#define AI_MATKEY_MAPPINGMODE_U(type, N) _AI_MATKEY_MAPPINGMODE_U_BASE,type,N - -// For backward compatibility and simplicity -//! @cond MATS_DOC_FULL -#define AI_MATKEY_MAPPINGMODE_U_DIFFUSE(N) \ - AI_MATKEY_MAPPINGMODE_U(aiTextureType_DIFFUSE,N) - -#define AI_MATKEY_MAPPINGMODE_U_SPECULAR(N) \ - AI_MATKEY_MAPPINGMODE_U(aiTextureType_SPECULAR,N) - -#define AI_MATKEY_MAPPINGMODE_U_AMBIENT(N) \ - AI_MATKEY_MAPPINGMODE_U(aiTextureType_AMBIENT,N) - -#define AI_MATKEY_MAPPINGMODE_U_EMISSIVE(N) \ - AI_MATKEY_MAPPINGMODE_U(aiTextureType_EMISSIVE,N) - -#define AI_MATKEY_MAPPINGMODE_U_NORMALS(N) \ - AI_MATKEY_MAPPINGMODE_U(aiTextureType_NORMALS,N) - -#define AI_MATKEY_MAPPINGMODE_U_HEIGHT(N) \ - AI_MATKEY_MAPPINGMODE_U(aiTextureType_HEIGHT,N) - -#define AI_MATKEY_MAPPINGMODE_U_SHININESS(N) \ - AI_MATKEY_MAPPINGMODE_U(aiTextureType_SHININESS,N) - -#define AI_MATKEY_MAPPINGMODE_U_OPACITY(N) \ - AI_MATKEY_MAPPINGMODE_U(aiTextureType_OPACITY,N) - -#define AI_MATKEY_MAPPINGMODE_U_DISPLACEMENT(N) \ - AI_MATKEY_MAPPINGMODE_U(aiTextureType_DISPLACEMENT,N) - -#define AI_MATKEY_MAPPINGMODE_U_LIGHTMAP(N) \ - AI_MATKEY_MAPPINGMODE_U(aiTextureType_LIGHTMAP,N) - -#define AI_MATKEY_MAPPINGMODE_U_REFLECTION(N) \ - AI_MATKEY_MAPPINGMODE_U(aiTextureType_REFLECTION,N) - -//! @endcond -// --------------------------------------------------------------------------- -#define AI_MATKEY_MAPPINGMODE_V(type, N) _AI_MATKEY_MAPPINGMODE_V_BASE,type,N - -// For backward compatibility and simplicity -//! @cond MATS_DOC_FULL -#define AI_MATKEY_MAPPINGMODE_V_DIFFUSE(N) \ - AI_MATKEY_MAPPINGMODE_V(aiTextureType_DIFFUSE,N) - -#define AI_MATKEY_MAPPINGMODE_V_SPECULAR(N) \ - AI_MATKEY_MAPPINGMODE_V(aiTextureType_SPECULAR,N) - -#define AI_MATKEY_MAPPINGMODE_V_AMBIENT(N) \ - AI_MATKEY_MAPPINGMODE_V(aiTextureType_AMBIENT,N) - -#define AI_MATKEY_MAPPINGMODE_V_EMISSIVE(N) \ - AI_MATKEY_MAPPINGMODE_V(aiTextureType_EMISSIVE,N) - -#define AI_MATKEY_MAPPINGMODE_V_NORMALS(N) \ - AI_MATKEY_MAPPINGMODE_V(aiTextureType_NORMALS,N) - -#define AI_MATKEY_MAPPINGMODE_V_HEIGHT(N) \ - AI_MATKEY_MAPPINGMODE_V(aiTextureType_HEIGHT,N) - -#define AI_MATKEY_MAPPINGMODE_V_SHININESS(N) \ - AI_MATKEY_MAPPINGMODE_V(aiTextureType_SHININESS,N) - -#define AI_MATKEY_MAPPINGMODE_V_OPACITY(N) \ - AI_MATKEY_MAPPINGMODE_V(aiTextureType_OPACITY,N) - -#define AI_MATKEY_MAPPINGMODE_V_DISPLACEMENT(N) \ - AI_MATKEY_MAPPINGMODE_V(aiTextureType_DISPLACEMENT,N) - -#define AI_MATKEY_MAPPINGMODE_V_LIGHTMAP(N) \ - AI_MATKEY_MAPPINGMODE_V(aiTextureType_LIGHTMAP,N) - -#define AI_MATKEY_MAPPINGMODE_V_REFLECTION(N) \ - AI_MATKEY_MAPPINGMODE_V(aiTextureType_REFLECTION,N) - -//! @endcond -// --------------------------------------------------------------------------- -#define AI_MATKEY_TEXMAP_AXIS(type, N) _AI_MATKEY_TEXMAP_AXIS_BASE,type,N - -// For backward compatibility and simplicity -//! @cond MATS_DOC_FULL -#define AI_MATKEY_TEXMAP_AXIS_DIFFUSE(N) \ - AI_MATKEY_TEXMAP_AXIS(aiTextureType_DIFFUSE,N) - -#define AI_MATKEY_TEXMAP_AXIS_SPECULAR(N) \ - AI_MATKEY_TEXMAP_AXIS(aiTextureType_SPECULAR,N) - -#define AI_MATKEY_TEXMAP_AXIS_AMBIENT(N) \ - AI_MATKEY_TEXMAP_AXIS(aiTextureType_AMBIENT,N) - -#define AI_MATKEY_TEXMAP_AXIS_EMISSIVE(N) \ - AI_MATKEY_TEXMAP_AXIS(aiTextureType_EMISSIVE,N) - -#define AI_MATKEY_TEXMAP_AXIS_NORMALS(N) \ - AI_MATKEY_TEXMAP_AXIS(aiTextureType_NORMALS,N) - -#define AI_MATKEY_TEXMAP_AXIS_HEIGHT(N) \ - AI_MATKEY_TEXMAP_AXIS(aiTextureType_HEIGHT,N) - -#define AI_MATKEY_TEXMAP_AXIS_SHININESS(N) \ - AI_MATKEY_TEXMAP_AXIS(aiTextureType_SHININESS,N) - -#define AI_MATKEY_TEXMAP_AXIS_OPACITY(N) \ - AI_MATKEY_TEXMAP_AXIS(aiTextureType_OPACITY,N) - -#define AI_MATKEY_TEXMAP_AXIS_DISPLACEMENT(N) \ - AI_MATKEY_TEXMAP_AXIS(aiTextureType_DISPLACEMENT,N) - -#define AI_MATKEY_TEXMAP_AXIS_LIGHTMAP(N) \ - AI_MATKEY_TEXMAP_AXIS(aiTextureType_LIGHTMAP,N) - -#define AI_MATKEY_TEXMAP_AXIS_REFLECTION(N) \ - AI_MATKEY_TEXMAP_AXIS(aiTextureType_REFLECTION,N) - -//! @endcond -// --------------------------------------------------------------------------- -#define AI_MATKEY_UVTRANSFORM(type, N) _AI_MATKEY_UVTRANSFORM_BASE,type,N - -// For backward compatibility and simplicity -//! @cond MATS_DOC_FULL -#define AI_MATKEY_UVTRANSFORM_DIFFUSE(N) \ - AI_MATKEY_UVTRANSFORM(aiTextureType_DIFFUSE,N) - -#define AI_MATKEY_UVTRANSFORM_SPECULAR(N) \ - AI_MATKEY_UVTRANSFORM(aiTextureType_SPECULAR,N) - -#define AI_MATKEY_UVTRANSFORM_AMBIENT(N) \ - AI_MATKEY_UVTRANSFORM(aiTextureType_AMBIENT,N) - -#define AI_MATKEY_UVTRANSFORM_EMISSIVE(N) \ - AI_MATKEY_UVTRANSFORM(aiTextureType_EMISSIVE,N) - -#define AI_MATKEY_UVTRANSFORM_NORMALS(N) \ - AI_MATKEY_UVTRANSFORM(aiTextureType_NORMALS,N) - -#define AI_MATKEY_UVTRANSFORM_HEIGHT(N) \ - AI_MATKEY_UVTRANSFORM(aiTextureType_HEIGHT,N) - -#define AI_MATKEY_UVTRANSFORM_SHININESS(N) \ - AI_MATKEY_UVTRANSFORM(aiTextureType_SHININESS,N) - -#define AI_MATKEY_UVTRANSFORM_OPACITY(N) \ - AI_MATKEY_UVTRANSFORM(aiTextureType_OPACITY,N) - -#define AI_MATKEY_UVTRANSFORM_DISPLACEMENT(N) \ - AI_MATKEY_UVTRANSFORM(aiTextureType_DISPLACEMENT,N) - -#define AI_MATKEY_UVTRANSFORM_LIGHTMAP(N) \ - AI_MATKEY_UVTRANSFORM(aiTextureType_LIGHTMAP,N) - -#define AI_MATKEY_UVTRANSFORM_REFLECTION(N) \ - AI_MATKEY_UVTRANSFORM(aiTextureType_REFLECTION,N) - -#define AI_MATKEY_UVTRANSFORM_UNKNOWN(N) \ - AI_MATKEY_UVTRANSFORM(aiTextureType_UNKNOWN,N) - -//! @endcond -// --------------------------------------------------------------------------- -#define AI_MATKEY_TEXFLAGS(type, N) _AI_MATKEY_TEXFLAGS_BASE,type,N - -// For backward compatibility and simplicity -//! @cond MATS_DOC_FULL -#define AI_MATKEY_TEXFLAGS_DIFFUSE(N) \ - AI_MATKEY_TEXFLAGS(aiTextureType_DIFFUSE,N) - -#define AI_MATKEY_TEXFLAGS_SPECULAR(N) \ - AI_MATKEY_TEXFLAGS(aiTextureType_SPECULAR,N) - -#define AI_MATKEY_TEXFLAGS_AMBIENT(N) \ - AI_MATKEY_TEXFLAGS(aiTextureType_AMBIENT,N) - -#define AI_MATKEY_TEXFLAGS_EMISSIVE(N) \ - AI_MATKEY_TEXFLAGS(aiTextureType_EMISSIVE,N) - -#define AI_MATKEY_TEXFLAGS_NORMALS(N) \ - AI_MATKEY_TEXFLAGS(aiTextureType_NORMALS,N) - -#define AI_MATKEY_TEXFLAGS_HEIGHT(N) \ - AI_MATKEY_TEXFLAGS(aiTextureType_HEIGHT,N) - -#define AI_MATKEY_TEXFLAGS_SHININESS(N) \ - AI_MATKEY_TEXFLAGS(aiTextureType_SHININESS,N) - -#define AI_MATKEY_TEXFLAGS_OPACITY(N) \ - AI_MATKEY_TEXFLAGS(aiTextureType_OPACITY,N) - -#define AI_MATKEY_TEXFLAGS_DISPLACEMENT(N) \ - AI_MATKEY_TEXFLAGS(aiTextureType_DISPLACEMENT,N) - -#define AI_MATKEY_TEXFLAGS_LIGHTMAP(N) \ - AI_MATKEY_TEXFLAGS(aiTextureType_LIGHTMAP,N) - -#define AI_MATKEY_TEXFLAGS_REFLECTION(N) \ - AI_MATKEY_TEXFLAGS(aiTextureType_REFLECTION,N) - -#define AI_MATKEY_TEXFLAGS_UNKNOWN(N) \ - AI_MATKEY_TEXFLAGS(aiTextureType_UNKNOWN,N) - -// --------------------------------------------------------------------------- -/** @brief Retrieve a material property with a specific key from the material - * - * @param pMat Pointer to the input material. May not be NULL - * @param pKey Key to search for. One of the AI_MATKEY_XXX constants. - * @param type Specifies the type of the texture to be retrieved ( - * e.g. diffuse, specular, height map ...) - * @param index Index of the texture to be retrieved. - * @param pPropOut Pointer to receive a pointer to a valid aiMaterialProperty - * structure or NULL if the key has not been found. */ -// --------------------------------------------------------------------------- -ASSIMP_API C_ENUM aiReturn aiGetMaterialProperty( - const C_STRUCT aiMaterial* pMat, - const char* pKey, - unsigned int type, - unsigned int index, - const C_STRUCT aiMaterialProperty** pPropOut); - -// --------------------------------------------------------------------------- -/** @brief Retrieve an array of float values with a specific key - * from the material - * - * Pass one of the AI_MATKEY_XXX constants for the last three parameters (the - * example reads the #AI_MATKEY_UVTRANSFORM property of the first diffuse texture) - * @code - * aiUVTransform trafo; - * unsigned int max = sizeof(aiUVTransform); - * if (AI_SUCCESS != aiGetMaterialFloatArray(mat, AI_MATKEY_UVTRANSFORM(aiTextureType_DIFFUSE,0), - * (float*)&trafo, &max) || sizeof(aiUVTransform) != max) - * { - * // error handling - * } - * @endcode - * - * @param pMat Pointer to the input material. May not be NULL - * @param pKey Key to search for. One of the AI_MATKEY_XXX constants. - * @param pOut Pointer to a buffer to receive the result. - * @param pMax Specifies the size of the given buffer, in float's. - * Receives the number of values (not bytes!) read. - * @param type (see the code sample above) - * @param index (see the code sample above) - * @return Specifies whether the key has been found. If not, the output - * arrays remains unmodified and pMax is set to 0.*/ -// --------------------------------------------------------------------------- -ASSIMP_API C_ENUM aiReturn aiGetMaterialFloatArray( - const C_STRUCT aiMaterial* pMat, - const char* pKey, - unsigned int type, - unsigned int index, - float* pOut, - unsigned int* pMax); - - -#ifdef __cplusplus - -// --------------------------------------------------------------------------- -/** @brief Retrieve a single float property with a specific key from the material. -* -* Pass one of the AI_MATKEY_XXX constants for the last three parameters (the -* example reads the #AI_MATKEY_SHININESS_STRENGTH property of the first diffuse texture) -* @code -* float specStrength = 1.f; // default value, remains unmodified if we fail. -* aiGetMaterialFloat(mat, AI_MATKEY_SHININESS_STRENGTH, -* (float*)&specStrength); -* @endcode -* -* @param pMat Pointer to the input material. May not be NULL -* @param pKey Key to search for. One of the AI_MATKEY_XXX constants. -* @param pOut Receives the output float. -* @param type (see the code sample above) -* @param index (see the code sample above) -* @return Specifies whether the key has been found. If not, the output -* float remains unmodified.*/ -// --------------------------------------------------------------------------- -inline aiReturn aiGetMaterialFloat(const aiMaterial* pMat, - const char* pKey, - unsigned int type, - unsigned int index, - float* pOut) -{ - return aiGetMaterialFloatArray(pMat,pKey,type,index,pOut,(unsigned int*)0x0); -} - -#else - -// Use our friend, the C preprocessor -#define aiGetMaterialFloat (pMat, type, index, pKey, pOut) \ - aiGetMaterialFloatArray(pMat, type, index, pKey, pOut, NULL) - -#endif //!__cplusplus - - -// --------------------------------------------------------------------------- -/** @brief Retrieve an array of integer values with a specific key - * from a material - * - * See the sample for aiGetMaterialFloatArray for more information.*/ -ASSIMP_API C_ENUM aiReturn aiGetMaterialIntegerArray(const C_STRUCT aiMaterial* pMat, - const char* pKey, - unsigned int type, - unsigned int index, - int* pOut, - unsigned int* pMax); - - -#ifdef __cplusplus - -// --------------------------------------------------------------------------- -/** @brief Retrieve an integer property with a specific key from a material - * - * See the sample for aiGetMaterialFloat for more information.*/ -// --------------------------------------------------------------------------- -inline aiReturn aiGetMaterialInteger(const C_STRUCT aiMaterial* pMat, - const char* pKey, - unsigned int type, - unsigned int index, - int* pOut) -{ - return aiGetMaterialIntegerArray(pMat,pKey,type,index,pOut,(unsigned int*)0x0); -} - -#else - -// use our friend, the C preprocessor -#define aiGetMaterialInteger (pMat, type, index, pKey, pOut) \ - aiGetMaterialIntegerArray(pMat, type, index, pKey, pOut, NULL) - -#endif //!__cplusplus - - - -// --------------------------------------------------------------------------- -/** @brief Retrieve a color value from the material property table -* -* See the sample for aiGetMaterialFloat for more information*/ -// --------------------------------------------------------------------------- -ASSIMP_API C_ENUM aiReturn aiGetMaterialColor(const C_STRUCT aiMaterial* pMat, - const char* pKey, - unsigned int type, - unsigned int index, - C_STRUCT aiColor4D* pOut); - - -// --------------------------------------------------------------------------- -/** @brief Retrieve a string from the material property table -* -* See the sample for aiGetMaterialFloat for more information.*/ -// --------------------------------------------------------------------------- -ASSIMP_API C_ENUM aiReturn aiGetMaterialString(const C_STRUCT aiMaterial* pMat, - const char* pKey, - unsigned int type, - unsigned int index, - C_STRUCT aiString* pOut); - -// --------------------------------------------------------------------------- -/** Get the number of textures for a particular texture type. - * @param[in] pMat Pointer to the input material. May not be NULL - * @param type Texture type to check for - * @return Number of textures for this type. - * @note A texture can be easily queried using #aiGetMaterialTexture() */ -// --------------------------------------------------------------------------- -ASSIMP_API unsigned int aiGetMaterialTextureCount(const C_STRUCT aiMaterial* pMat, - C_ENUM aiTextureType type); - -// --------------------------------------------------------------------------- -/** @brief Helper function to get all values pertaining to a particular - * texture slot from a material structure. - * - * This function is provided just for convenience. You could also read the - * texture by parsing all of its properties manually. This function bundles - * all of them in a huge function monster. - * - * @param[in] mat Pointer to the input material. May not be NULL - * @param[in] type Specifies the texture stack to read from (e.g. diffuse, - * specular, height map ...). - * @param[in] index Index of the texture. The function fails if the - * requested index is not available for this texture type. - * #aiGetMaterialTextureCount() can be used to determine the number of - * textures in a particular texture stack. - * @param[out] path Receives the output path - * This parameter must be non-null. - * @param mapping The texture mapping mode to be used. - * Pass NULL if you're not interested in this information. - * @param[out] uvindex For UV-mapped textures: receives the index of the UV - * source channel. Unmodified otherwise. - * Pass NULL if you're not interested in this information. - * @param[out] blend Receives the blend factor for the texture - * Pass NULL if you're not interested in this information. - * @param[out] op Receives the texture blend operation to be perform between - * this texture and the previous texture. - * Pass NULL if you're not interested in this information. - * @param[out] mapmode Receives the mapping modes to be used for the texture. - * Pass NULL if you're not interested in this information. Otherwise, - * pass a pointer to an array of two aiTextureMapMode's (one for each - * axis, UV order). - * @return AI_SUCCESS on success, otherwise something else. Have fun.*/ -// --------------------------------------------------------------------------- -#ifdef __cplusplus -ASSIMP_API aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat, - aiTextureType type, - unsigned int index, - aiString* path, - aiTextureMapping* mapping = NULL, - unsigned int* uvindex = NULL, - float* blend = NULL, - aiTextureOp* op = NULL, - aiTextureMapMode* mapmode = NULL, - unsigned int* flags = NULL); -#else -C_ENUM aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat, - C_ENUM aiTextureType type, - unsigned int index, - C_STRUCT aiString* path, - C_ENUM aiTextureMapping* mapping /*= NULL*/, - unsigned int* uvindex /*= NULL*/, - float* blend /*= NULL*/, - C_ENUM aiTextureOp* op /*= NULL*/, - C_ENUM aiTextureMapMode* mapmode /*= NULL*/, - unsigned int* flags /*= NULL*/); -#endif // !#ifdef __cplusplus - -#ifdef __cplusplus -} - -#include "aiMaterial.inl" - -#endif //!__cplusplus -#endif //!!AI_MATERIAL_H_INC diff --git a/3rdparty/assimp/include/aiMaterial.inl b/3rdparty/assimp/include/aiMaterial.inl deleted file mode 100644 index 6be16ff6..00000000 --- a/3rdparty/assimp/include/aiMaterial.inl +++ /dev/null @@ -1,191 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiMaterial.inl - * @brief Defines the C++ getters for the material system - */ - -#ifndef AI_MATERIAL_INL_INC -#define AI_MATERIAL_INL_INC - -//! @cond never - -// --------------------------------------------------------------------------- -inline aiReturn aiMaterial::GetTexture( aiTextureType type, - unsigned int index, - C_STRUCT aiString* path, - aiTextureMapping* mapping /*= NULL*/, - unsigned int* uvindex /*= NULL*/, - float* blend /*= NULL*/, - aiTextureOp* op /*= NULL*/, - aiTextureMapMode* mapmode /*= NULL*/) const -{ - return ::aiGetMaterialTexture(this,type,index,path,mapping,uvindex,blend,op,mapmode); -} - -// --------------------------------------------------------------------------- -inline unsigned int aiMaterial::GetTextureCount(aiTextureType type) const -{ - return ::aiGetMaterialTextureCount(this,type); -} - -// --------------------------------------------------------------------------- -template <typename Type> -inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, - unsigned int idx, Type* pOut, - unsigned int* pMax) const -{ - unsigned int iNum = pMax ? *pMax : 1; - - const aiMaterialProperty* prop; - const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx, - (const aiMaterialProperty**)&prop); - if ( AI_SUCCESS == ret ) { - - if (prop->mDataLength < sizeof(Type)*iNum) { - return AI_FAILURE; - } - - // if (::strcmp(prop->mData,(char*)aiPTI_Buffer)!=0) - // return AI_FAILURE; - - iNum = std::min((size_t)iNum,prop->mDataLength / sizeof(Type)); - memcpy(pOut,prop->mData,iNum * sizeof(Type)); - if (pMax) { - *pMax = iNum; - } - } - return ret; -} - -// --------------------------------------------------------------------------- -template <typename Type> -inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, - unsigned int idx,Type& pOut) const -{ - const aiMaterialProperty* prop; - const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx, - (const aiMaterialProperty**)&prop); - if ( AI_SUCCESS == ret ) { - - /* - if (prop->mDataLength < sizeof(Type)) { - return AI_FAILURE; - } - - if (strcmp(prop->mData,(char*)aiPTI_Buffer)!=0) { - return AI_FAILURE; - } - - memcpy(&pOut,prop->mData,sizeof(Type)); - */ - - if (prop->mType == aiPTI_Buffer) { - return AI_FAILURE; - } else { - if (prop->mDataLength < sizeof(Type)) { - return AI_FAILURE; - } else { - memcpy(&pOut,prop->mData,sizeof(Type)); - } - } - } - return ret; -} -// --------------------------------------------------------------------------- -template <> -inline aiReturn aiMaterial::Get<float>(const char* pKey,unsigned int type, - unsigned int idx,float* pOut, - unsigned int* pMax) const -{ - return ::aiGetMaterialFloatArray(this,pKey,type,idx,pOut,pMax); -} -// --------------------------------------------------------------------------- -template <> -inline aiReturn aiMaterial::Get<int>(const char* pKey,unsigned int type, - unsigned int idx,int* pOut, - unsigned int* pMax) const -{ - return ::aiGetMaterialIntegerArray(this,pKey,type,idx,pOut,pMax); -} - -// --------------------------------------------------------------------------- -template <> -inline aiReturn aiMaterial::Get<float>(const char* pKey,unsigned int type, - unsigned int idx,float& pOut) const -{ - return aiGetMaterialFloat(this,pKey,type,idx,&pOut); -} -// --------------------------------------------------------------------------- -template <> -inline aiReturn aiMaterial::Get<int>(const char* pKey,unsigned int type, - unsigned int idx,int& pOut) const -{ - return aiGetMaterialInteger(this,pKey,type,idx,&pOut); -} -// --------------------------------------------------------------------------- -template <> -inline aiReturn aiMaterial::Get<aiColor4D>(const char* pKey,unsigned int type, - unsigned int idx,aiColor4D& pOut) const -{ - return aiGetMaterialColor(this,pKey,type,idx,&pOut); -} -// --------------------------------------------------------------------------- -template <> -inline aiReturn aiMaterial::Get<aiColor3D>(const char* pKey,unsigned int type, - unsigned int idx,aiColor3D& pOut) const -{ - aiColor4D c; - const aiReturn ret = aiGetMaterialColor(this,pKey,type,idx,&c); - pOut = aiColor3D(c.r,c.g,c.b); - return ret; -} -// --------------------------------------------------------------------------- -template <> -inline aiReturn aiMaterial::Get<aiString>(const char* pKey,unsigned int type, - unsigned int idx,aiString& pOut) const -{ - return aiGetMaterialString(this,pKey,type,idx,&pOut); -} - -//! @endcond - -#endif //! AI_MATERIAL_INL_INC diff --git a/3rdparty/assimp/include/aiMatrix3x3.h b/3rdparty/assimp/include/aiMatrix3x3.h deleted file mode 100644 index dc3d6314..00000000 --- a/3rdparty/assimp/include/aiMatrix3x3.h +++ /dev/null @@ -1,166 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiMatrix3x3.h - * @brief Definition of a 3x3 matrix, including operators when compiling in C++ - */ -#ifndef AI_MATRIX3x3_H_INC -#define AI_MATRIX3x3_H_INC - -#ifdef __cplusplus -extern "C" { -#endif - -struct aiMatrix4x4; -struct aiVector2D; - -// --------------------------------------------------------------------------- -/** @brief Represents a row-major 3x3 matrix - * - * There's much confusion about matrix layouts (colum vs. row order). - * This is *always* a row-major matrix. Even with the - * aiProcess_ConvertToLeftHanded flag. - */ -struct aiMatrix3x3 -{ -#ifdef __cplusplus - - aiMatrix3x3 () : - a1(1.0f), a2(0.0f), a3(0.0f), - b1(0.0f), b2(1.0f), b3(0.0f), - c1(0.0f), c2(0.0f), c3(1.0f) {} - - aiMatrix3x3 ( float _a1, float _a2, float _a3, - float _b1, float _b2, float _b3, - float _c1, float _c2, float _c3) : - a1(_a1), a2(_a2), a3(_a3), - b1(_b1), b2(_b2), b3(_b3), - c1(_c1), c2(_c2), c3(_c3) - {} - -public: - - // matrix multiplication. beware, not commutative - aiMatrix3x3& operator *= (const aiMatrix3x3& m); - aiMatrix3x3 operator * (const aiMatrix3x3& m) const; - - // array access operators - float* operator[] (unsigned int p_iIndex); - const float* operator[] (unsigned int p_iIndex) const; - - // comparison operators - bool operator== (const aiMatrix4x4 m) const; - bool operator!= (const aiMatrix4x4 m) const; - -public: - - // ------------------------------------------------------------------- - /** @brief Construction from a 4x4 matrix. The remaining parts - * of the matrix are ignored. - */ - explicit aiMatrix3x3( const aiMatrix4x4& pMatrix); - - // ------------------------------------------------------------------- - /** @brief Transpose the matrix - */ - aiMatrix3x3& Transpose(); - - // ------------------------------------------------------------------- - /** @brief Invert the matrix. - * If the matrix is not invertible all elements are set to qnan. - * Beware, use (f != f) to check whether a float f is qnan. - */ - aiMatrix3x3& Inverse(); - float Determinant() const; - -public: - // ------------------------------------------------------------------- - /** @brief Returns a rotation matrix for a rotation around z - * @param a Rotation angle, in radians - * @param out Receives the output matrix - * @return Reference to the output matrix - */ - static aiMatrix3x3& RotationZ(float a, aiMatrix3x3& out); - - // ------------------------------------------------------------------- - /** @brief Returns a rotation matrix for a rotation around - * an arbitrary axis. - * - * @param a Rotation angle, in radians - * @param axis Axis to rotate around - * @param out To be filled - */ - static aiMatrix3x3& Rotation( float a, - const aiVector3D& axis, aiMatrix3x3& out); - - // ------------------------------------------------------------------- - /** @brief Returns a translation matrix - * @param v Translation vector - * @param out Receives the output matrix - * @return Reference to the output matrix - */ - static aiMatrix3x3& Translation( const aiVector2D& v, aiMatrix3x3& out); - - // ------------------------------------------------------------------- - /** @brief A function for creating a rotation matrix that rotates a - * vector called "from" into another vector called "to". - * Input : from[3], to[3] which both must be *normalized* non-zero vectors - * Output: mtx[3][3] -- a 3x3 matrix in colum-major form - * Authors: Tomas M�ller, John Hughes - * "Efficiently Building a Matrix to Rotate One Vector to Another" - * Journal of Graphics Tools, 4(4):1-4, 1999 - */ - static aiMatrix3x3& FromToMatrix(const aiVector3D& from, - const aiVector3D& to, aiMatrix3x3& out); - -#endif // __cplusplus - - - float a1, a2, a3; - float b1, b2, b3; - float c1, c2, c3; -}; - -#ifdef __cplusplus -} // end of extern C -#endif - -#endif // AI_MATRIX3x3_H_INC diff --git a/3rdparty/assimp/include/aiMatrix3x3.inl b/3rdparty/assimp/include/aiMatrix3x3.inl deleted file mode 100644 index 3a9e6162..00000000 --- a/3rdparty/assimp/include/aiMatrix3x3.inl +++ /dev/null @@ -1,250 +0,0 @@ -/** @file aiMatrix3x3.inl - * @brief Inline implementation of the 3x3 matrix operators - */ -#ifndef AI_MATRIX3x3_INL_INC -#define AI_MATRIX3x3_INL_INC - -#include "aiMatrix3x3.h" - -#ifdef __cplusplus -#include "aiMatrix4x4.h" -#include <algorithm> -#include <limits> - -// ------------------------------------------------------------------------------------------------ -// Construction from a 4x4 matrix. The remaining parts of the matrix are ignored. -inline aiMatrix3x3::aiMatrix3x3( const aiMatrix4x4& pMatrix) -{ - a1 = pMatrix.a1; a2 = pMatrix.a2; a3 = pMatrix.a3; - b1 = pMatrix.b1; b2 = pMatrix.b2; b3 = pMatrix.b3; - c1 = pMatrix.c1; c2 = pMatrix.c2; c3 = pMatrix.c3; -} - -// ------------------------------------------------------------------------------------------------ -inline aiMatrix3x3& aiMatrix3x3::operator *= (const aiMatrix3x3& m) -{ - *this = aiMatrix3x3(m.a1 * a1 + m.b1 * a2 + m.c1 * a3, - m.a2 * a1 + m.b2 * a2 + m.c2 * a3, - m.a3 * a1 + m.b3 * a2 + m.c3 * a3, - m.a1 * b1 + m.b1 * b2 + m.c1 * b3, - m.a2 * b1 + m.b2 * b2 + m.c2 * b3, - m.a3 * b1 + m.b3 * b2 + m.c3 * b3, - m.a1 * c1 + m.b1 * c2 + m.c1 * c3, - m.a2 * c1 + m.b2 * c2 + m.c2 * c3, - m.a3 * c1 + m.b3 * c2 + m.c3 * c3); - return *this; -} - -// ------------------------------------------------------------------------------------------------ -inline aiMatrix3x3 aiMatrix3x3::operator* (const aiMatrix3x3& m) const -{ - aiMatrix3x3 temp( *this); - temp *= m; - return temp; -} - -// ------------------------------------------------------------------------------------------------ -inline float* aiMatrix3x3::operator[] (unsigned int p_iIndex) -{ - return &this->a1 + p_iIndex * 3; -} - -// ------------------------------------------------------------------------------------------------ -inline const float* aiMatrix3x3::operator[] (unsigned int p_iIndex) const -{ - return &this->a1 + p_iIndex * 3; -} - -// ------------------------------------------------------------------------------------------------ -inline bool aiMatrix3x3::operator== (const aiMatrix4x4 m) const -{ - return a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && - b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && - c1 == m.c1 && c2 == m.c2 && c3 == m.c3; -} - -// ------------------------------------------------------------------------------------------------ -inline bool aiMatrix3x3::operator!= (const aiMatrix4x4 m) const -{ - return !(*this == m); -} - -// ------------------------------------------------------------------------------------------------ -inline aiMatrix3x3& aiMatrix3x3::Transpose() -{ - // (float&) don't remove, GCC complains cause of packed fields - std::swap( (float&)a2, (float&)b1); - std::swap( (float&)a3, (float&)c1); - std::swap( (float&)b3, (float&)c2); - return *this; -} - -// ---------------------------------------------------------------------------------------- -inline float aiMatrix3x3::Determinant() const -{ - return a1*b2*c3 - a1*b3*c2 + a2*b3*c1 - a2*b1*c3 + a3*b1*c2 - a3*b2*c1; -} - -// ---------------------------------------------------------------------------------------- -inline aiMatrix3x3& aiMatrix3x3::Inverse() -{ - // Compute the reciprocal determinant - float det = Determinant(); - if(det == 0.0f) - { - // Matrix not invertible. Setting all elements to nan is not really - // correct in a mathematical sense but it is easy to debug for the - // programmer. - const float nan = std::numeric_limits<float>::quiet_NaN(); - *this = aiMatrix3x3( nan,nan,nan,nan,nan,nan,nan,nan,nan); - - return *this; - } - - float invdet = 1.0f / det; - - aiMatrix3x3 res; - res.a1 = invdet * (b2 * c3 - b3 * c2); - res.a2 = -invdet * (a2 * c3 - a3 * c2); - res.a3 = invdet * (a2 * b3 - a3 * b2); - res.b1 = -invdet * (b1 * c3 - b3 * c1); - res.b2 = invdet * (a1 * c3 - a3 * c1); - res.b3 = -invdet * (a1 * b3 - a3 * b1); - res.c1 = invdet * (b1 * c2 - b2 * c1); - res.c2 = -invdet * (a1 * c2 - a2 * c1); - res.c3 = invdet * (a1 * b2 - a2 * b1); - *this = res; - - return *this; -} - -// ------------------------------------------------------------------------------------------------ -inline aiMatrix3x3& aiMatrix3x3::RotationZ(float a, aiMatrix3x3& out) -{ - out.a1 = out.b2 = ::cos(a); - out.b1 = ::sin(a); - out.a2 = - out.b1; - - out.a3 = out.b3 = out.c1 = out.c2 = 0.f; - out.c3 = 1.f; - - return out; -} - -// ------------------------------------------------------------------------------------------------ -// Returns a rotation matrix for a rotation around an arbitrary axis. -inline aiMatrix3x3& aiMatrix3x3::Rotation( float a, const aiVector3D& axis, aiMatrix3x3& out) -{ - float c = cos( a), s = sin( a), t = 1 - c; - float x = axis.x, y = axis.y, z = axis.z; - - // 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.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; - - return out; -} - -// ------------------------------------------------------------------------------------------------ -inline aiMatrix3x3& aiMatrix3x3::Translation( const aiVector2D& v, aiMatrix3x3& out) -{ - out = aiMatrix3x3(); - out.a3 = v.x; - out.b3 = v.y; - return out; -} - -// ---------------------------------------------------------------------------------------- -/** A function for creating a rotation matrix that rotates a vector called - * "from" into another vector called "to". - * Input : from[3], to[3] which both must be *normalized* non-zero vectors - * Output: mtx[3][3] -- a 3x3 matrix in colum-major form - * Authors: Tomas M�ller, John Hughes - * "Efficiently Building a Matrix to Rotate One Vector to Another" - * Journal of Graphics Tools, 4(4):1-4, 1999 - */ -// ---------------------------------------------------------------------------------------- -inline aiMatrix3x3& aiMatrix3x3::FromToMatrix(const aiVector3D& from, - const aiVector3D& to, aiMatrix3x3& mtx) -{ - const float e = from * to; - const float f = (e < 0)? -e:e; - - if (f > 1.0 - 0.00001f) /* "from" and "to"-vector almost parallel */ - { - aiVector3D u,v; /* temporary storage vectors */ - aiVector3D x; /* vector most nearly orthogonal to "from" */ - - x.x = (from.x > 0.0)? from.x : -from.x; - x.y = (from.y > 0.0)? from.y : -from.y; - x.z = (from.z > 0.0)? from.z : -from.z; - - if (x.x < x.y) - { - if (x.x < x.z) - { - x.x = 1.0; x.y = x.z = 0.0; - } - else - { - x.z = 1.0; x.y = x.z = 0.0; - } - } - else - { - if (x.y < x.z) - { - x.y = 1.0; x.x = x.z = 0.0; - } - else - { - x.z = 1.0; x.x = x.y = 0.0; - } - } - - 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; - - const float c1 = 2.0f / (u * u); - const float c2 = 2.0f / (v * v); - const float c3 = c1 * c2 * (u * v); - - for (unsigned int i = 0; i < 3; i++) - { - for (unsigned int j = 0; j < 3; j++) - { - mtx[i][j] = - c1 * u[i] * u[j] - c2 * v[i] * v[j] - + c3 * v[i] * u[j]; - } - mtx[i][i] += 1.0; - } - } - else /* the most common case, unless "from"="to", or "from"=-"to" */ - { - const aiVector3D v = from ^ to; - /* ... use this hand optimized version (9 mults less) */ - const float h = 1.0f/(1.0f + e); /* optimization by Gottfried Chen */ - const float hvx = h * v.x; - const float hvz = h * v.z; - const float hvxy = hvx * v.y; - const float hvxz = hvx * v.z; - const float hvyz = hvz * v.y; - mtx[0][0] = e + hvx * v.x; - mtx[0][1] = hvxy - v.z; - mtx[0][2] = hvxz + v.y; - - mtx[1][0] = hvxy + v.z; - mtx[1][1] = e + h * v.y * v.y; - mtx[1][2] = hvyz - v.x; - - mtx[2][0] = hvxz - v.y; - mtx[2][1] = hvyz + v.x; - mtx[2][2] = e + hvz * v.z; - } - return mtx; -} - - -#endif // __cplusplus -#endif // AI_MATRIX3x3_INL_INC diff --git a/3rdparty/assimp/include/aiMatrix4x4.h b/3rdparty/assimp/include/aiMatrix4x4.h deleted file mode 100644 index 625c9b9a..00000000 --- a/3rdparty/assimp/include/aiMatrix4x4.h +++ /dev/null @@ -1,240 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ -/** @file aiMatrix4x4.h - * @brief 4x4 matrix structure, including operators when compiling in C++ - */ -#ifndef AI_MATRIX4X4_H_INC -#define AI_MATRIX4X4_H_INC - -#ifdef __cplusplus -extern "C" { -#endif - -struct aiMatrix3x3; -struct aiQuaternion; - -#include "./Compiler/pushpack1.h" - -// --------------------------------------------------------------------------- -/** @brief Represents a row-major 4x4 matrix, use this for homogeneous - * coordinates. - * - * There's much confusion about matrix layouts (colum vs. row order). - * This is *always* a row-major matrix. Even with the - * aiProcess_ConvertToLeftHanded flag. - */ -struct aiMatrix4x4 -{ -#ifdef __cplusplus - - // default c'tor, init to zero - aiMatrix4x4 () : - a1(1.0f), a2(0.0f), a3(0.0f), a4(0.0f), - b1(0.0f), b2(1.0f), b3(0.0f), b4(0.0f), - c1(0.0f), c2(0.0f), c3(1.0f), c4(0.0f), - d1(0.0f), d2(0.0f), d3(0.0f), d4(1.0f) - {} - - // from single values - aiMatrix4x4 ( float _a1, float _a2, float _a3, float _a4, - float _b1, float _b2, float _b3, float _b4, - float _c1, float _c2, float _c3, float _c4, - float _d1, float _d2, float _d3, float _d4) : - a1(_a1), a2(_a2), a3(_a3), a4(_a4), - b1(_b1), b2(_b2), b3(_b3), b4(_b4), - c1(_c1), c2(_c2), c3(_c3), c4(_c4), - d1(_d1), d2(_d2), d3(_d3), d4(_d4) - {} - - - // ------------------------------------------------------------------- - /** @brief Constructor from 3x3 matrix. - * The remaining elements are set to identity. - */ - explicit aiMatrix4x4( const aiMatrix3x3& m); - -public: - - // array access operators - float* operator[] (unsigned int p_iIndex); - const float* operator[] (unsigned int p_iIndex) const; - - // comparison operators - bool operator== (const aiMatrix4x4 m) const; - bool operator!= (const aiMatrix4x4 m) const; - - // Matrix multiplication. Not commutative. - aiMatrix4x4& operator *= (const aiMatrix4x4& m); - aiMatrix4x4 operator * (const aiMatrix4x4& m) const; - -public: - - // ------------------------------------------------------------------- - /** @brief Transpose the matrix - */ - aiMatrix4x4& Transpose(); - - // ------------------------------------------------------------------- - /** @brief Invert the matrix. - * If the matrix is not invertible all elements are set to qnan. - * Beware, use (f != f) to check whether a float f is qnan. - */ - aiMatrix4x4& Inverse(); - float Determinant() const; - - - // ------------------------------------------------------------------- - /** @brief Returns true of the matrix is the identity matrix. - * The check is performed against a not so small epsilon. - */ - inline bool IsIdentity() const; - - // ------------------------------------------------------------------- - /** @brief Decompose a trafo matrix into its original components - * @param scaling Receives the output scaling for the x,y,z axes - * @param rotation Receives the output rotation as a hamilton - * quaternion - * @param position Receives the output position for the x,y,z axes - */ - void Decompose (aiVector3D& scaling, aiQuaternion& rotation, - aiVector3D& position) const; - - // ------------------------------------------------------------------- - /** @brief Decompose a trafo matrix with no scaling into its - * original components - * @param rotation Receives the output rotation as a hamilton - * quaternion - * @param position Receives the output position for the x,y,z axes - */ - void DecomposeNoScaling (aiQuaternion& rotation, - aiVector3D& position) const; - - - // ------------------------------------------------------------------- - /** @brief Creates a trafo matrix from a set of euler angles - * @param x Rotation angle for the x-axis, in radians - * @param y Rotation angle for the y-axis, in radians - * @param z Rotation angle for the z-axis, in radians - */ - aiMatrix4x4& FromEulerAnglesXYZ(float x, float y, float z); - aiMatrix4x4& FromEulerAnglesXYZ(const aiVector3D& blubb); - -public: - // ------------------------------------------------------------------- - /** @brief Returns a rotation matrix for a rotation around the x axis - * @param a Rotation angle, in radians - * @param out Receives the output matrix - * @return Reference to the output matrix - */ - static aiMatrix4x4& RotationX(float a, aiMatrix4x4& out); - - // ------------------------------------------------------------------- - /** @brief Returns a rotation matrix for a rotation around the y axis - * @param a Rotation angle, in radians - * @param out Receives the output matrix - * @return Reference to the output matrix - */ - static aiMatrix4x4& RotationY(float a, aiMatrix4x4& out); - - // ------------------------------------------------------------------- - /** @brief Returns a rotation matrix for a rotation around the z axis - * @param a Rotation angle, in radians - * @param out Receives the output matrix - * @return Reference to the output matrix - */ - static aiMatrix4x4& RotationZ(float a, aiMatrix4x4& out); - - // ------------------------------------------------------------------- - /** Returns a rotation matrix for a rotation around an arbitrary axis. - * @param a Rotation angle, in radians - * @param axis Rotation axis, should be a normalized vector. - * @param out Receives the output matrix - * @return Reference to the output matrix - */ - static aiMatrix4x4& Rotation(float a, const aiVector3D& axis, - aiMatrix4x4& out); - - // ------------------------------------------------------------------- - /** @brief Returns a translation matrix - * @param v Translation vector - * @param out Receives the output matrix - * @return Reference to the output matrix - */ - static aiMatrix4x4& Translation( const aiVector3D& v, aiMatrix4x4& out); - - // ------------------------------------------------------------------- - /** @brief Returns a scaling matrix - * @param v Scaling vector - * @param out Receives the output matrix - * @return Reference to the output matrix - */ - static aiMatrix4x4& Scaling( const aiVector3D& v, aiMatrix4x4& out); - - // ------------------------------------------------------------------- - /** @brief A function for creating a rotation matrix that rotates a - * vector called "from" into another vector called "to". - * Input : from[3], to[3] which both must be *normalized* non-zero vectors - * Output: mtx[3][3] -- a 3x3 matrix in colum-major form - * Authors: Tomas M�ller, John Hughes - * "Efficiently Building a Matrix to Rotate One Vector to Another" - * Journal of Graphics Tools, 4(4):1-4, 1999 - */ - static aiMatrix4x4& FromToMatrix(const aiVector3D& from, - const aiVector3D& to, aiMatrix4x4& out); - -#endif // __cplusplus - - float a1, a2, a3, a4; - float b1, b2, b3, b4; - float c1, c2, c3, c4; - float d1, d2, d3, d4; - -} PACK_STRUCT; // !class aiMatrix4x4 - - -#include "./Compiler/poppack1.h" - -#ifdef __cplusplus -} // end extern "C" - - -#endif // __cplusplus -#endif // AI_MATRIX4X4_H_INC diff --git a/3rdparty/assimp/include/aiMatrix4x4.inl b/3rdparty/assimp/include/aiMatrix4x4.inl deleted file mode 100644 index c24fcede..00000000 --- a/3rdparty/assimp/include/aiMatrix4x4.inl +++ /dev/null @@ -1,419 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiMatrix4x4.inl - * @brief Inline implementation of the 4x4 matrix operators - */ -#ifndef AI_MATRIX4x4_INL_INC -#define AI_MATRIX4x4_INL_INC - -#include "aiMatrix4x4.h" - -#ifdef __cplusplus -#include "aiMatrix3x3.h" - -#include <algorithm> -#include <limits> -#include <math.h> - -#include "aiAssert.h" -#include "aiQuaternion.h" - -// ---------------------------------------------------------------------------------------- -inline aiMatrix4x4::aiMatrix4x4( const aiMatrix3x3& m) -{ - a1 = m.a1; a2 = m.a2; a3 = m.a3; a4 = 0.0f; - b1 = m.b1; b2 = m.b2; b3 = m.b3; b4 = 0.0f; - c1 = m.c1; c2 = m.c2; c3 = m.c3; c4 = 0.0f; - d1 = 0.0f; d2 = 0.0f; d3 = 0.0f; d4 = 1.0f; -} - -// ---------------------------------------------------------------------------------------- -inline aiMatrix4x4& aiMatrix4x4::operator *= (const aiMatrix4x4& m) -{ - *this = aiMatrix4x4( - m.a1 * a1 + m.b1 * a2 + m.c1 * a3 + m.d1 * a4, - m.a2 * a1 + m.b2 * a2 + m.c2 * a3 + m.d2 * a4, - m.a3 * a1 + m.b3 * a2 + m.c3 * a3 + m.d3 * a4, - m.a4 * a1 + m.b4 * a2 + m.c4 * a3 + m.d4 * a4, - m.a1 * b1 + m.b1 * b2 + m.c1 * b3 + m.d1 * b4, - m.a2 * b1 + m.b2 * b2 + m.c2 * b3 + m.d2 * b4, - m.a3 * b1 + m.b3 * b2 + m.c3 * b3 + m.d3 * b4, - m.a4 * b1 + m.b4 * b2 + m.c4 * b3 + m.d4 * b4, - m.a1 * c1 + m.b1 * c2 + m.c1 * c3 + m.d1 * c4, - m.a2 * c1 + m.b2 * c2 + m.c2 * c3 + m.d2 * c4, - m.a3 * c1 + m.b3 * c2 + m.c3 * c3 + m.d3 * c4, - m.a4 * c1 + m.b4 * c2 + m.c4 * c3 + m.d4 * c4, - m.a1 * d1 + m.b1 * d2 + m.c1 * d3 + m.d1 * d4, - m.a2 * d1 + m.b2 * d2 + m.c2 * d3 + m.d2 * d4, - m.a3 * d1 + m.b3 * d2 + m.c3 * d3 + m.d3 * d4, - m.a4 * d1 + m.b4 * d2 + m.c4 * d3 + m.d4 * d4); - return *this; -} - -// ---------------------------------------------------------------------------------------- -inline aiMatrix4x4 aiMatrix4x4::operator* (const aiMatrix4x4& m) const -{ - aiMatrix4x4 temp( *this); - temp *= m; - return temp; -} - - -// ---------------------------------------------------------------------------------------- -inline aiMatrix4x4& aiMatrix4x4::Transpose() -{ - // (float&) don't remove, GCC complains cause of packed fields - std::swap( (float&)b1, (float&)a2); - std::swap( (float&)c1, (float&)a3); - std::swap( (float&)c2, (float&)b3); - std::swap( (float&)d1, (float&)a4); - std::swap( (float&)d2, (float&)b4); - std::swap( (float&)d3, (float&)c4); - return *this; -} - - -// ---------------------------------------------------------------------------------------- -inline float aiMatrix4x4::Determinant() const -{ - return a1*b2*c3*d4 - a1*b2*c4*d3 + a1*b3*c4*d2 - a1*b3*c2*d4 - + a1*b4*c2*d3 - a1*b4*c3*d2 - a2*b3*c4*d1 + a2*b3*c1*d4 - - a2*b4*c1*d3 + a2*b4*c3*d1 - a2*b1*c3*d4 + a2*b1*c4*d3 - + a3*b4*c1*d2 - a3*b4*c2*d1 + a3*b1*c2*d4 - a3*b1*c4*d2 - + a3*b2*c4*d1 - a3*b2*c1*d4 - a4*b1*c2*d3 + a4*b1*c3*d2 - - a4*b2*c3*d1 + a4*b2*c1*d3 - a4*b3*c1*d2 + a4*b3*c2*d1; -} - -// ---------------------------------------------------------------------------------------- -inline aiMatrix4x4& aiMatrix4x4::Inverse() -{ - // Compute the reciprocal determinant - float det = Determinant(); - if(det == 0.0f) - { - // Matrix not invertible. Setting all elements to nan is not really - // correct in a mathematical sense but it is easy to debug for the - // programmer. - const float nan = std::numeric_limits<float>::quiet_NaN(); - *this = aiMatrix4x4( - nan,nan,nan,nan, - nan,nan,nan,nan, - nan,nan,nan,nan, - nan,nan,nan,nan); - - return *this; - } - - float invdet = 1.0f / det; - - aiMatrix4x4 res; - res.a1 = invdet * (b2 * (c3 * d4 - c4 * d3) + b3 * (c4 * d2 - c2 * d4) + b4 * (c2 * d3 - c3 * d2)); - res.a2 = -invdet * (a2 * (c3 * d4 - c4 * d3) + a3 * (c4 * d2 - c2 * d4) + a4 * (c2 * d3 - c3 * d2)); - res.a3 = invdet * (a2 * (b3 * d4 - b4 * d3) + a3 * (b4 * d2 - b2 * d4) + a4 * (b2 * d3 - b3 * d2)); - res.a4 = -invdet * (a2 * (b3 * c4 - b4 * c3) + a3 * (b4 * c2 - b2 * c4) + a4 * (b2 * c3 - b3 * c2)); - res.b1 = -invdet * (b1 * (c3 * d4 - c4 * d3) + b3 * (c4 * d1 - c1 * d4) + b4 * (c1 * d3 - c3 * d1)); - res.b2 = invdet * (a1 * (c3 * d4 - c4 * d3) + a3 * (c4 * d1 - c1 * d4) + a4 * (c1 * d3 - c3 * d1)); - res.b3 = -invdet * (a1 * (b3 * d4 - b4 * d3) + a3 * (b4 * d1 - b1 * d4) + a4 * (b1 * d3 - b3 * d1)); - res.b4 = invdet * (a1 * (b3 * c4 - b4 * c3) + a3 * (b4 * c1 - b1 * c4) + a4 * (b1 * c3 - b3 * c1)); - res.c1 = invdet * (b1 * (c2 * d4 - c4 * d2) + b2 * (c4 * d1 - c1 * d4) + b4 * (c1 * d2 - c2 * d1)); - res.c2 = -invdet * (a1 * (c2 * d4 - c4 * d2) + a2 * (c4 * d1 - c1 * d4) + a4 * (c1 * d2 - c2 * d1)); - res.c3 = invdet * (a1 * (b2 * d4 - b4 * d2) + a2 * (b4 * d1 - b1 * d4) + a4 * (b1 * d2 - b2 * d1)); - res.c4 = -invdet * (a1 * (b2 * c4 - b4 * c2) + a2 * (b4 * c1 - b1 * c4) + a4 * (b1 * c2 - b2 * c1)); - res.d1 = -invdet * (b1 * (c2 * d3 - c3 * d2) + b2 * (c3 * d1 - c1 * d3) + b3 * (c1 * d2 - c2 * d1)); - res.d2 = invdet * (a1 * (c2 * d3 - c3 * d2) + a2 * (c3 * d1 - c1 * d3) + a3 * (c1 * d2 - c2 * d1)); - res.d3 = -invdet * (a1 * (b2 * d3 - b3 * d2) + a2 * (b3 * d1 - b1 * d3) + a3 * (b1 * d2 - b2 * d1)); - res.d4 = invdet * (a1 * (b2 * c3 - b3 * c2) + a2 * (b3 * c1 - b1 * c3) + a3 * (b1 * c2 - b2 * c1)); - *this = res; - - return *this; -} - -// ---------------------------------------------------------------------------------------- -inline float* aiMatrix4x4::operator[](unsigned int p_iIndex) -{ - return &this->a1 + p_iIndex * 4; -} - -// ---------------------------------------------------------------------------------------- -inline const float* aiMatrix4x4::operator[](unsigned int p_iIndex) const -{ - return &this->a1 + p_iIndex * 4; -} - -// ---------------------------------------------------------------------------------------- -inline bool aiMatrix4x4::operator== (const aiMatrix4x4 m) const -{ - return (a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && a4 == m.a4 && - b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && b4 == m.b4 && - c1 == m.c1 && c2 == m.c2 && c3 == m.c3 && c4 == m.c4 && - d1 == m.d1 && d2 == m.d2 && d3 == m.d3 && d4 == m.d4); -} - -// ---------------------------------------------------------------------------------------- -inline bool aiMatrix4x4::operator!= (const aiMatrix4x4 m) const -{ - return !(*this == m); -} - -// ---------------------------------------------------------------------------------------- -inline void aiMatrix4x4::Decompose (aiVector3D& scaling, aiQuaternion& rotation, - aiVector3D& position) const -{ - const aiMatrix4x4& _this = *this; - - // extract translation - position.x = _this[0][3]; - position.y = _this[1][3]; - position.z = _this[2][3]; - - // extract the rows of the matrix - aiVector3D vRows[3] = { - aiVector3D(_this[0][0],_this[1][0],_this[2][0]), - aiVector3D(_this[0][1],_this[1][1],_this[2][1]), - aiVector3D(_this[0][2],_this[1][2],_this[2][2]) - }; - - // extract the scaling factors - scaling.x = vRows[0].Length(); - scaling.y = vRows[1].Length(); - scaling.z = vRows[2].Length(); - - // and remove all scaling from the matrix - if(scaling.x) - { - vRows[0] /= scaling.x; - } - if(scaling.y) - { - vRows[1] /= scaling.y; - } - if(scaling.z) - { - vRows[2] /= scaling.z; - } - - // build a 3x3 rotation matrix - aiMatrix3x3 m(vRows[0].x,vRows[1].x,vRows[2].x, - vRows[0].y,vRows[1].y,vRows[2].y, - vRows[0].z,vRows[1].z,vRows[2].z); - - // and generate the rotation quaternion from it - rotation = aiQuaternion(m); -} - -// ---------------------------------------------------------------------------------------- -inline void aiMatrix4x4::DecomposeNoScaling (aiQuaternion& rotation, - aiVector3D& position) const -{ - const aiMatrix4x4& _this = *this; - - // extract translation - position.x = _this[0][3]; - position.y = _this[1][3]; - position.z = _this[2][3]; - - // extract rotation - rotation = aiQuaternion((aiMatrix3x3)_this); -} - -// ---------------------------------------------------------------------------------------- -inline aiMatrix4x4& aiMatrix4x4::FromEulerAnglesXYZ(const aiVector3D& blubb) -{ - return FromEulerAnglesXYZ(blubb.x,blubb.y,blubb.z); -} - -// ---------------------------------------------------------------------------------------- -inline aiMatrix4x4& aiMatrix4x4::FromEulerAnglesXYZ(float x, float y, float z) -{ - aiMatrix4x4& _this = *this; - - float cr = cos( x ); - float sr = sin( x ); - float cp = cos( y ); - float sp = sin( y ); - float cy = cos( z ); - float sy = sin( z ); - - _this.a1 = cp*cy ; - _this.a2 = cp*sy; - _this.a3 = -sp ; - - float srsp = sr*sp; - float crsp = cr*sp; - - _this.b1 = srsp*cy-cr*sy ; - _this.b2 = srsp*sy+cr*cy ; - _this.b3 = sr*cp ; - - _this.c1 = crsp*cy+sr*sy ; - _this.c2 = crsp*sy-sr*cy ; - _this.c3 = cr*cp ; - - return *this; -} - -// ---------------------------------------------------------------------------------------- -inline bool aiMatrix4x4::IsIdentity() const -{ - // Use a small epsilon to solve floating-point inaccuracies - const static float epsilon = 10e-3f; - - return (a2 <= epsilon && a2 >= -epsilon && - a3 <= epsilon && a3 >= -epsilon && - a4 <= epsilon && a4 >= -epsilon && - b1 <= epsilon && b1 >= -epsilon && - b3 <= epsilon && b3 >= -epsilon && - b4 <= epsilon && b4 >= -epsilon && - c1 <= epsilon && c1 >= -epsilon && - c2 <= epsilon && c2 >= -epsilon && - c4 <= epsilon && c4 >= -epsilon && - d1 <= epsilon && d1 >= -epsilon && - d2 <= epsilon && d2 >= -epsilon && - d3 <= epsilon && d3 >= -epsilon && - a1 <= 1.f+epsilon && a1 >= 1.f-epsilon && - b2 <= 1.f+epsilon && b2 >= 1.f-epsilon && - c3 <= 1.f+epsilon && c3 >= 1.f-epsilon && - d4 <= 1.f+epsilon && d4 >= 1.f-epsilon); -} - -// ---------------------------------------------------------------------------------------- -inline aiMatrix4x4& aiMatrix4x4::RotationX(float a, aiMatrix4x4& out) -{ - /* - | 1 0 0 0 | - M = | 0 cos(A) -sin(A) 0 | - | 0 sin(A) cos(A) 0 | - | 0 0 0 1 | */ - out = aiMatrix4x4(); - out.b2 = out.c3 = cos(a); - out.b3 = -(out.c2 = sin(a)); - return out; -} - -// ---------------------------------------------------------------------------------------- -inline aiMatrix4x4& aiMatrix4x4::RotationY(float a, aiMatrix4x4& out) -{ - /* - | cos(A) 0 sin(A) 0 | - M = | 0 1 0 0 | - | -sin(A) 0 cos(A) 0 | - | 0 0 0 1 | - */ - out = aiMatrix4x4(); - out.a1 = out.c3 = cos(a); - out.c1 = -(out.a3 = sin(a)); - return out; -} - -// ---------------------------------------------------------------------------------------- -inline aiMatrix4x4& aiMatrix4x4::RotationZ(float a, aiMatrix4x4& out) -{ - /* - | cos(A) -sin(A) 0 0 | - M = | sin(A) cos(A) 0 0 | - | 0 0 1 0 | - | 0 0 0 1 | */ - out = aiMatrix4x4(); - out.a1 = out.b2 = cos(a); - out.a2 = -(out.b1 = sin(a)); - return out; -} - -// ---------------------------------------------------------------------------------------- -// Returns a rotation matrix for a rotation around an arbitrary axis. -inline aiMatrix4x4& aiMatrix4x4::Rotation( float a, const aiVector3D& axis, aiMatrix4x4& out) -{ - float c = cos( a), s = sin( a), t = 1 - c; - float x = axis.x, y = axis.y, z = axis.z; - - // 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.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.a4 = out.b4 = out.c4 = 0.0f; - out.d1 = out.d2 = out.d3 = 0.0f; - out.d4 = 1.0f; - - return out; -} - -// ---------------------------------------------------------------------------------------- -inline aiMatrix4x4& aiMatrix4x4::Translation( const aiVector3D& v, aiMatrix4x4& out) -{ - out = aiMatrix4x4(); - out.a4 = v.x; - out.b4 = v.y; - out.c4 = v.z; - return out; -} - -// ---------------------------------------------------------------------------------------- -inline aiMatrix4x4& aiMatrix4x4::Scaling( const aiVector3D& v, aiMatrix4x4& out) -{ - out = aiMatrix4x4(); - out.a1 = v.x; - out.b2 = v.y; - out.c3 = v.z; - return out; -} - -// ---------------------------------------------------------------------------------------- -/** A function for creating a rotation matrix that rotates a vector called - * "from" into another vector called "to". - * Input : from[3], to[3] which both must be *normalized* non-zero vectors - * Output: mtx[3][3] -- a 3x3 matrix in colum-major form - * Authors: Tomas M�ller, John Hughes - * "Efficiently Building a Matrix to Rotate One Vector to Another" - * Journal of Graphics Tools, 4(4):1-4, 1999 - */ -// ---------------------------------------------------------------------------------------- -inline aiMatrix4x4& aiMatrix4x4::FromToMatrix(const aiVector3D& from, - const aiVector3D& to, aiMatrix4x4& mtx) -{ - aiMatrix3x3 m3; - aiMatrix3x3::FromToMatrix(from,to,m3); - mtx = aiMatrix4x4(m3); - return mtx; -} - -#endif // __cplusplus -#endif // AI_MATRIX4x4_INL_INC diff --git a/3rdparty/assimp/include/aiMesh.h b/3rdparty/assimp/include/aiMesh.h deleted file mode 100644 index 1fec346d..00000000 --- a/3rdparty/assimp/include/aiMesh.h +++ /dev/null @@ -1,733 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiMesh.h - * @brief Declares the data structures in which the imported geometry is - returned by ASSIMP: aiMesh, aiFace and aiBone data structures. - */ -#ifndef INCLUDED_AI_MESH_H -#define INCLUDED_AI_MESH_H - -#include "aiTypes.h" - -#ifdef __cplusplus -extern "C" { -#endif - -// --------------------------------------------------------------------------- -// Limits. These values are required to match the settings Assimp was -// compiled against. Therfore, do not redefine them unless you build the -// library from source using the same definitions. -// --------------------------------------------------------------------------- - -/** @def AI_MAX_FACE_INDICES - * Maximum number of indices per face (polygon). */ - -#ifndef AI_MAX_FACE_INDICES -# define AI_MAX_FACE_INDICES 0x7fff -#endif - -/** @def AI_MAX_BONE_WEIGHTS - * Maximum number of indices per face (polygon). */ - -#ifndef AI_MAX_BONE_WEIGHTS -# define AI_MAX_BONE_WEIGHTS 0x7fffffff -#endif - -/** @def AI_MAX_VERTICES - * Maximum number of vertices per mesh. */ - -#ifndef AI_MAX_VERTICES -# define AI_MAX_VERTICES 0x7fffffff -#endif - -/** @def AI_MAX_FACES - * Maximum number of faces per mesh. */ - -#ifndef AI_MAX_FACES -# define AI_MAX_FACES 0x7fffffff -#endif - -/** @def AI_MAX_NUMBER_OF_COLOR_SETS - * Supported number of vertex color sets per mesh. */ - -#ifndef AI_MAX_NUMBER_OF_COLOR_SETS -# define AI_MAX_NUMBER_OF_COLOR_SETS 0x4 -#endif // !! AI_MAX_NUMBER_OF_COLOR_SETS - -/** @def AI_MAX_NUMBER_OF_TEXTURECOORDS - * Supported number of texture coord sets (UV(W) channels) per mesh */ - -#ifndef AI_MAX_NUMBER_OF_TEXTURECOORDS -# define AI_MAX_NUMBER_OF_TEXTURECOORDS 0x4 -#endif // !! AI_MAX_NUMBER_OF_TEXTURECOORDS - -// --------------------------------------------------------------------------- -/** @brief A single face in a mesh, referring to multiple vertices. - * - * If mNumIndices is 3, we call the face 'triangle', for mNumIndices > 3 - * it's called 'polygon' (hey, that's just a definition!). - * <br> - * aiMesh::mPrimitiveTypes can be queried to quickly examine which types of - * primitive are actually present in a mesh. The #aiProcess_SortByPType flag - * executes a special post-processing algorithm which splits meshes with - * *different* primitive types mixed up (e.g. lines and triangles) in several - * 'clean' submeshes. Furthermore there is a configuration option ( - * #AI_CONFIG_PP_SBP_REMOVE) to force #aiProcess_SortByPType to remove - * specific kinds of primitives from the imported scene, completely and forever. - * In many cases you'll probably want to set this setting to - * @code - * aiPrimitiveType_LINE|aiPrimitiveType_POINT - * @endcode - * Together with the #aiProcess_Triangulate flag you can then be sure that - * #aiFace::mNumIndices is always 3. - * @note Take a look at the @link data Data Structures page @endlink for - * more information on the layout and winding order of a face. - */ -struct aiFace -{ - //! Number of indices defining this face. - //! The maximum value for this member is #AI_MAX_FACE_INDICES. - unsigned int mNumIndices; - - //! Pointer to the indices array. Size of the array is given in numIndices. - unsigned int* mIndices; - -#ifdef __cplusplus - - //! Default constructor - aiFace() - { - mNumIndices = 0; mIndices = NULL; - } - - //! Default destructor. Delete the index array - ~aiFace() - { - delete [] mIndices; - } - - //! Copy constructor. Copy the index array - aiFace( const aiFace& o) - { - mIndices = NULL; - *this = o; - } - - //! Assignment operator. Copy the index array - const aiFace& operator = ( const aiFace& o) - { - if (&o == this) - return *this; - - delete[] mIndices; - mNumIndices = o.mNumIndices; - mIndices = new unsigned int[mNumIndices]; - ::memcpy( mIndices, o.mIndices, mNumIndices * sizeof( unsigned int)); - return *this; - } - - //! Comparison operator. Checks whether the index array - //! of two faces is identical - bool operator== (const aiFace& o) const - { - if (mIndices == o.mIndices)return true; - else if (mIndices && mNumIndices == o.mNumIndices) - { - for (unsigned int i = 0;i < this->mNumIndices;++i) - if (mIndices[i] != o.mIndices[i])return false; - return true; - } - return false; - } - - //! Inverse comparison operator. Checks whether the index - //! array of two faces is NOT identical - bool operator != (const aiFace& o) const - { - return !(*this == o); - } -#endif // __cplusplus -}; // struct aiFace - - -// --------------------------------------------------------------------------- -/** @brief A single influence of a bone on a vertex. - */ -struct aiVertexWeight -{ - //! Index of the vertex which is influenced by the bone. - unsigned int mVertexId; - - //! The strength of the influence in the range (0...1). - //! The influence from all bones at one vertex amounts to 1. - float mWeight; - -#ifdef __cplusplus - - //! Default constructor - aiVertexWeight() { } - - //! Initialisation from a given index and vertex weight factor - //! \param pID ID - //! \param pWeight Vertex weight factor - aiVertexWeight( unsigned int pID, float pWeight) - : mVertexId( pID), mWeight( pWeight) - { /* nothing to do here */ } - -#endif // __cplusplus -}; - - -// --------------------------------------------------------------------------- -/** @brief A single bone of a mesh. - * - * A bone has a name by which it can be found in the frame hierarchy and by - * which it can be addressed by animations. In addition it has a number of - * influences on vertices. - */ -struct aiBone -{ - //! The name of the bone. - C_STRUCT aiString mName; - - //! The number of vertices affected by this bone - //! The maximum value for this member is #AI_MAX_BONE_WEIGHTS. - unsigned int mNumWeights; - - //! The vertices affected by this bone - C_STRUCT aiVertexWeight* mWeights; - - //! Matrix that transforms from mesh space to bone space in bind pose - C_STRUCT aiMatrix4x4 mOffsetMatrix; - -#ifdef __cplusplus - - //! Default constructor - aiBone() - { - mNumWeights = 0; mWeights = NULL; - } - - //! Copy constructor - aiBone(const aiBone& other) - { - mNumWeights = other.mNumWeights; - mOffsetMatrix = other.mOffsetMatrix; - mName = other.mName; - - if (other.mWeights && other.mNumWeights) - { - mWeights = new aiVertexWeight[mNumWeights]; - ::memcpy(mWeights,other.mWeights,mNumWeights * sizeof(aiVertexWeight)); - } - } - - //! Destructor - deletes the array of vertex weights - ~aiBone() - { - delete [] mWeights; - } -#endif // __cplusplus -}; - - -// --------------------------------------------------------------------------- -/** @brief Enumerates the types of geometric primitives supported by Assimp. - * - * @see aiFace Face data structure - * @see aiProcess_SortByPType Per-primitive sorting of meshes - * @see aiProcess_Triangulate Automatic triangulation - * @see AI_CONFIG_PP_SBP_REMOVE Removal of specific primitive types. - */ -enum aiPrimitiveType -{ - /** A point primitive. - * - * This is just a single vertex in the virtual world, - * #aiFace contains just one index for such a primitive. - */ - aiPrimitiveType_POINT = 0x1, - - /** A line primitive. - * - * This is a line defined through a start and an end position. - * #aiFace contains exactly two indices for such a primitive. - */ - aiPrimitiveType_LINE = 0x2, - - /** A triangular primitive. - * - * A triangle consists of three indices. - */ - aiPrimitiveType_TRIANGLE = 0x4, - - /** A higher-level polygon with more than 3 edges. - * - * A triangle is a polygon, but polygon in this context means - * "all polygons that are not triangles". The "Triangulate"-Step - * is provided for your convenience, it splits all polygons in - * triangles (which are much easier to handle). - */ - aiPrimitiveType_POLYGON = 0x8, - - - /** This value is not used. It is just here to force the - * compiler to map this enum to a 32 Bit integer. - */ -#ifndef SWIG - _aiPrimitiveType_Force32Bit = 0x9fffffff -#endif -}; //! enum aiPrimitiveType - -// Get the #aiPrimitiveType flag for a specific number of face indices -#define AI_PRIMITIVE_TYPE_FOR_N_INDICES(n) \ - ((n) > 3 ? aiPrimitiveType_POLYGON : (aiPrimitiveType)(1u << ((n)-1))) - - - -// --------------------------------------------------------------------------- -/** @brief NOT CURRENTLY IN USE. An AnimMesh is an attachment to an #aiMesh stores per-vertex - * animations for a particular frame. - * - * You may think of an #aiAnimMesh as a `patch` for the host mesh, which - * replaces only certain vertex data streams at a particular time. - * Each mesh stores n attached attached meshes (#aiMesh::mAnimMeshes). - * The actual relationship between the time line and anim meshes is - * established by #aiMeshAnim, which references singular mesh attachments - * by their ID and binds them to a time offset. -*/ -struct aiAnimMesh -{ - /** Replacement for aiMesh::mVertices. If this array is non-NULL, - * it *must* contain mNumVertices entries. The corresponding - * array in the host mesh must be non-NULL as well - animation - * meshes may neither add or nor remove vertex components (if - * a replacement array is NULL and the corresponding source - * array is not, the source data is taken instead)*/ - C_STRUCT aiVector3D* mVertices; - - /** Replacement for aiMesh::mNormals. */ - C_STRUCT aiVector3D* mNormals; - - /** Replacement for aiMesh::mTangents. */ - C_STRUCT aiVector3D* mTangents; - - /** Replacement for aiMesh::mBitangents. */ - C_STRUCT aiVector3D* mBitangents; - - /** Replacement for aiMesh::mColors */ - C_STRUCT aiColor4D* mColors[AI_MAX_NUMBER_OF_COLOR_SETS]; - - /** Replacement for aiMesh::mTextureCoords */ - C_STRUCT aiVector3D* mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS]; - - /** The number of vertices in the aiAnimMesh, and thus the length of all - * the member arrays. - * - * This has always the same value as the mNumVertices property in the - * corresponding aiMesh. It is duplicated here merely to make the length - * of the member arrays accessible even if the aiMesh is not known, e.g. - * from language bindings. - */ - unsigned int mNumVertices; - -#ifdef __cplusplus - - aiAnimMesh() - : mVertices() - , mNormals() - , mTangents() - , mBitangents() - { - // fixme consider moving this to the ctor initializer list as well - for ( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++){ - mTextureCoords[a] = NULL; - } - for ( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) { - mColors[a] = NULL; - } - } - - ~aiAnimMesh() - { - delete [] mVertices; - delete [] mNormals; - delete [] mTangents; - delete [] mBitangents; - for ( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) { - delete [] mTextureCoords[a]; - } - for ( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) { - delete [] mColors[a]; - } - } - - /** Check whether the anim mesh overrides the vertex positions - * of its host mesh*/ - bool HasPositions() const { - return mVertices != NULL; - } - - /** Check whether the anim mesh overrides the vertex normals - * of its host mesh*/ - bool HasNormals() const { - return mNormals != NULL; - } - - /** Check whether the anim mesh overrides the vertex tangents - * and bitangents of its host mesh. As for aiMesh, - * tangents and bitangents always go together. */ - bool HasTangentsAndBitangents() const { - return mTangents != NULL; - } - - /** Check whether the anim mesh overrides a particular - * set of vertex colors on his host mesh. - * @param pIndex 0<index<AI_MAX_NUMBER_OF_COLOR_SETS */ - bool HasVertexColors( unsigned int pIndex) const { - return pIndex >= AI_MAX_NUMBER_OF_COLOR_SETS ? false : mColors[pIndex] != NULL; - } - - /** Check whether the anim mesh overrides a particular - * set of texture coordinates on his host mesh. - * @param pIndex 0<index<AI_MAX_NUMBER_OF_TEXTURECOORDS */ - bool HasTextureCoords( unsigned int pIndex) const { - return pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? false : mTextureCoords[pIndex] != NULL; - } - -#endif -}; - - -// --------------------------------------------------------------------------- -/** @brief A mesh represents a geometry or model with a single material. -* -* It usually consists of a number of vertices and a series of primitives/faces -* referencing the vertices. In addition there might be a series of bones, each -* of them addressing a number of vertices with a certain weight. Vertex data -* is presented in channels with each channel containing a single per-vertex -* information such as a set of texture coords or a normal vector. -* If a data pointer is non-null, the corresponding data stream is present. -* From C++-programs you can also use the comfort functions Has*() to -* test for the presence of various data streams. -* -* A Mesh uses only a single material which is referenced by a material ID. -* @note The mPositions member is usually not optional. However, vertex positions -* *could* be missing if the #AI_SCENE_FLAGS_INCOMPLETE flag is set in -* @code -* aiScene::mFlags -* @endcode -*/ -struct aiMesh -{ - /** Bitwise combination of the members of the #aiPrimitiveType enum. - * This specifies which types of primitives are present in the mesh. - * The "SortByPrimitiveType"-Step can be used to make sure the - * output meshes consist of one primitive type each. - */ - unsigned int mPrimitiveTypes; - - /** The number of vertices in this mesh. - * This is also the size of all of the per-vertex data arrays. - * The maximum value for this member is #AI_MAX_VERTICES. - */ - unsigned int mNumVertices; - - /** The number of primitives (triangles, polygons, lines) in this mesh. - * This is also the size of the mFaces array. - * The maximum value for this member is #AI_MAX_FACES. - */ - unsigned int mNumFaces; - - /** Vertex positions. - * This array is always present in a mesh. The array is - * mNumVertices in size. - */ - C_STRUCT aiVector3D* mVertices; - - /** Vertex normals. - * The array contains normalized vectors, NULL if not present. - * The array is mNumVertices in size. Normals are undefined for - * point and line primitives. A mesh consisting of points and - * lines only may not have normal vectors. Meshes with mixed - * primitive types (i.e. lines and triangles) may have normals, - * but the normals for vertices that are only referenced by - * point or line primitives are undefined and set to QNaN (WARN: - * qNaN compares to inequal to *everything*, even to qNaN itself. - * Using code like this to check whether a field is qnan is: - * @code - * #define IS_QNAN(f) (f != f) - * @endcode - * still dangerous because even 1.f == 1.f could evaluate to false! ( - * remember the subtleties of IEEE754 artithmetics). Use stuff like - * @c fpclassify instead. - * @note Normal vectors computed by Assimp are always unit-length. - * However, this needn't apply for normals that have been taken - * directly from the model file. - */ - C_STRUCT aiVector3D* mNormals; - - /** Vertex tangents. - * The tangent of a vertex points in the direction of the positive - * X texture axis. The array contains normalized vectors, NULL if - * not present. The array is mNumVertices in size. A mesh consisting - * of points and lines only may not have normal vectors. Meshes with - * mixed primitive types (i.e. lines and triangles) may have - * normals, but the normals for vertices that are only referenced by - * point or line primitives are undefined and set to qNaN. See - * the #mNormals member for a detailled discussion of qNaNs. - * @note If the mesh contains tangents, it automatically also - * contains bitangents (the bitangent is just the cross product of - * tangent and normal vectors). - */ - C_STRUCT aiVector3D* mTangents; - - /** Vertex bitangents. - * The bitangent of a vertex points in the direction of the positive - * Y texture axis. The array contains normalized vectors, NULL if not - * present. The array is mNumVertices in size. - * @note If the mesh contains tangents, it automatically also contains - * bitangents. - */ - C_STRUCT aiVector3D* mBitangents; - - /** Vertex color sets. - * A mesh may contain 0 to #AI_MAX_NUMBER_OF_COLOR_SETS vertex - * colors per vertex. NULL if not present. Each array is - * mNumVertices in size if present. - */ - C_STRUCT aiColor4D* mColors[AI_MAX_NUMBER_OF_COLOR_SETS]; - - /** Vertex texture coords, also known as UV channels. - * A mesh may contain 0 to AI_MAX_NUMBER_OF_TEXTURECOORDS per - * vertex. NULL if not present. The array is mNumVertices in size. - */ - C_STRUCT aiVector3D* mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS]; - - /** Specifies the number of components for a given UV channel. - * Up to three channels are supported (UVW, for accessing volume - * or cube maps). If the value is 2 for a given channel n, the - * component p.z of mTextureCoords[n][p] is set to 0.0f. - * If the value is 1 for a given channel, p.y is set to 0.0f, too. - * @note 4D coords are not supported - */ - unsigned int mNumUVComponents[AI_MAX_NUMBER_OF_TEXTURECOORDS]; - - /** The faces the mesh is constructed from. - * Each face refers to a number of vertices by their indices. - * This array is always present in a mesh, its size is given - * in mNumFaces. If the #AI_SCENE_FLAGS_NON_VERBOSE_FORMAT - * is NOT set each face references an unique set of vertices. - */ - C_STRUCT aiFace* mFaces; - - /** The number of bones this mesh contains. - * Can be 0, in which case the mBones array is NULL. - */ - unsigned int mNumBones; - - /** The bones of this mesh. - * A bone consists of a name by which it can be found in the - * frame hierarchy and a set of vertex weights. - */ - C_STRUCT aiBone** mBones; - - /** The material used by this mesh. - * A mesh does use only a single material. If an imported model uses - * multiple materials, the import splits up the mesh. Use this value - * as index into the scene's material list. - */ - unsigned int mMaterialIndex; - - /** Name of the mesh. Meshes can be named, but this is not a - * requirement and leaving this field empty is totally fine. - * There are mainly three uses for mesh names: - * - some formats name nodes and meshes independently. - * - importers tend to split meshes up to meet the - * one-material-per-mesh requirement. Assigning - * the same (dummy) name to each of the result meshes - * aids the caller at recovering the original mesh - * partitioning. - * - Vertex animations refer to meshes by their names. - **/ - C_STRUCT aiString mName; - - - /** NOT CURRENTLY IN USE. The number of attachment meshes */ - unsigned int mNumAnimMeshes; - - /** NOT CURRENTLY IN USE. Attachment meshes for this mesh, for vertex-based animation. - * Attachment meshes carry replacement data for some of the - * mesh'es vertex components (usually positions, normals). */ - C_STRUCT aiAnimMesh** mAnimMeshes; - - -#ifdef __cplusplus - - //! Default constructor. Initializes all members to 0 - aiMesh() - { - mNumVertices = 0; - mNumFaces = 0; - - mNumAnimMeshes = 0; - - mPrimitiveTypes = 0; - mVertices = NULL; mFaces = NULL; - mNormals = NULL; mTangents = NULL; - mBitangents = NULL; - mAnimMeshes = NULL; - - for ( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) - { - mNumUVComponents[a] = 0; - mTextureCoords[a] = NULL; - } - for ( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) - mColors[a] = NULL; - mNumBones = 0; mBones = NULL; - mMaterialIndex = 0; - } - - //! Deletes all storage allocated for the mesh - ~aiMesh() - { - delete [] mVertices; - delete [] mNormals; - delete [] mTangents; - delete [] mBitangents; - for ( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++) { - delete [] mTextureCoords[a]; - } - for ( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++) { - delete [] mColors[a]; - } - - // DO NOT REMOVE THIS ADDITIONAL CHECK - if (mNumBones && mBones) { - for ( unsigned int a = 0; a < mNumBones; a++) { - delete mBones[a]; - } - delete [] mBones; - } - - if (mNumAnimMeshes && mAnimMeshes) { - for ( unsigned int a = 0; a < mNumAnimMeshes; a++) { - delete mAnimMeshes[a]; - } - delete [] mAnimMeshes; - } - - delete [] mFaces; - } - - //! Check whether the mesh contains positions. Provided no special - //! scene flags are set (such as #AI_SCENE_FLAGS_ANIM_SKELETON_ONLY), - //! this will always be true - bool HasPositions() const - { return mVertices != NULL && mNumVertices > 0; } - - //! Check whether the mesh contains faces. If no special scene flags - //! are set this should always return true - bool HasFaces() const - { return mFaces != NULL && mNumFaces > 0; } - - //! Check whether the mesh contains normal vectors - bool HasNormals() const - { return mNormals != NULL && mNumVertices > 0; } - - //! Check whether the mesh contains tangent and bitangent vectors - //! It is not possible that it contains tangents and no bitangents - //! (or the other way round). The existence of one of them - //! implies that the second is there, too. - bool HasTangentsAndBitangents() const - { return mTangents != NULL && mBitangents != NULL && mNumVertices > 0; } - - //! Check whether the mesh contains a vertex color set - //! \param pIndex Index of the vertex color set - bool HasVertexColors( unsigned int pIndex) const - { - if ( pIndex >= AI_MAX_NUMBER_OF_COLOR_SETS) - return false; - else - return mColors[pIndex] != NULL && mNumVertices > 0; - } - - //! Check whether the mesh contains a texture coordinate set - //! \param pIndex Index of the texture coordinates set - bool HasTextureCoords( unsigned int pIndex) const - { - if ( pIndex >= AI_MAX_NUMBER_OF_TEXTURECOORDS) - return false; - else - return mTextureCoords[pIndex] != NULL && mNumVertices > 0; - } - - //! Get the number of UV channels the mesh contains - unsigned int GetNumUVChannels() const - { - unsigned int n = 0; - while (n < AI_MAX_NUMBER_OF_TEXTURECOORDS && mTextureCoords[n])++n; - return n; - } - - //! Get the number of vertex color channels the mesh contains - unsigned int GetNumColorChannels() const - { - unsigned int n = 0; - while (n < AI_MAX_NUMBER_OF_COLOR_SETS && mColors[n])++n; - return n; - } - - //! Check whether the mesh contains bones - inline bool HasBones() const - { return mBones != NULL && mNumBones > 0; } - -#endif // __cplusplus -}; - - -#ifdef __cplusplus -} -#endif //! extern "C" -#endif // __AI_MESH_H_INC - diff --git a/3rdparty/assimp/include/aiPostProcess.h b/3rdparty/assimp/include/aiPostProcess.h deleted file mode 100644 index f9a23107..00000000 --- a/3rdparty/assimp/include/aiPostProcess.h +++ /dev/null @@ -1,604 +0,0 @@ -/* -Open Asset Import Library (ASSIMP) ----------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ - -/** @file aiPostProcess.h - * @brief Definitions for import post processing steps - */ -#ifndef AI_POSTPROCESS_H_INC -#define AI_POSTPROCESS_H_INC - -#include "aiTypes.h" - -#ifdef __cplusplus -extern "C" { -#endif - -// ----------------------------------------------------------------------------------- -/** @enum aiPostProcessSteps - * @brief Defines the flags for all possible post processing steps. - * - * @see Importer::ReadFile - * @see aiImportFile - * @see aiImportFileEx - */ -// ----------------------------------------------------------------------------------- -enum aiPostProcessSteps -{ - - // ------------------------------------------------------------------------- - /** <hr>Calculates the tangents and bitangents for the imported meshes. - * - * Does nothing if a mesh does not have normals. You might want this post - * processing step to be executed if you plan to use tangent space calculations - * such as normal mapping applied to the meshes. There's a config setting, - * <tt>#AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE</tt>, which allows you to specify - * a maximum smoothing angle for the algorithm. However, usually you'll - * want to leave it at the default value. Thanks. - */ - aiProcess_CalcTangentSpace = 0x1, - - // ------------------------------------------------------------------------- - /** <hr>Identifies and joins identical vertex data sets within all - * imported meshes. - * - * After this step is run each mesh does contain only unique vertices anymore, - * so a vertex is possibly used by multiple faces. You usually want - * to use this post processing step. If your application deals with - * indexed geometry, this step is compulsory or you'll just waste rendering - * time. <b>If this flag is not specified</b>, no vertices are referenced by - * more than one face and <b>no index buffer is required</b> for rendering. - */ - aiProcess_JoinIdenticalVertices = 0x2, - - // ------------------------------------------------------------------------- - /** <hr>Converts all the imported data to a left-handed coordinate space. - * - * By default the data is returned in a right-handed coordinate space which - * for example OpenGL prefers. In this space, +X points to the right, - * +Z points towards the viewer and and +Y points upwards. In the DirectX - * coordinate space +X points to the right, +Y points upwards and +Z points - * away from the viewer. - * - * You'll probably want to consider this flag if you use Direct3D for - * rendering. The #aiProcess_ConvertToLeftHanded flag supersedes this - * setting and bundles all conversions typically required for D3D-based - * applications. - */ - aiProcess_MakeLeftHanded = 0x4, - - // ------------------------------------------------------------------------- - /** <hr>Triangulates all faces of all meshes. - * - * By default the imported mesh data might contain faces with more than 3 - * indices. For rendering you'll usually want all faces to be triangles. - * This post processing step splits up all higher faces to triangles. - * Line and point primitives are *not* modified!. If you want - * 'triangles only' with no other kinds of primitives, try the following - * solution: - * <ul> - * <li>Specify both #aiProcess_Triangulate and #aiProcess_SortByPType </li> - * </li>Ignore all point and line meshes when you process assimp's output</li> - * </ul> - */ - aiProcess_Triangulate = 0x8, - - // ------------------------------------------------------------------------- - /** <hr>Removes some parts of the data structure (animations, materials, - * light sources, cameras, textures, vertex components). - * - * The components to be removed are specified in a separate - * configuration option, <tt>#AI_CONFIG_PP_RVC_FLAGS</tt>. This is quite useful - * if you don't need all parts of the output structure. Especially vertex - * colors are rarely used today ... . Calling this step to remove unrequired - * stuff from the pipeline as early as possible results in an increased - * performance and a better optimized output data structure. - * This step is also useful if you want to force Assimp to recompute - * normals or tangents. The corresponding steps don't recompute them if - * they're already there (loaded from the source asset). By using this - * step you can make sure they are NOT there. - * - * This flag is a poor one, mainly because its purpose is usually - * misunderstood. Consider the following case: a 3d model has been exported - * from a CAD app, it has per-face vertex colors. Vertex positions can't be - * shared, thus the #aiProcess_JoinIdenticalVertices step fails to - * optimize the data. Just because these nasty, little vertex colors. - * Most apps don't even process them, so it's all for nothing. By using - * this step, unneeded components are excluded as early as possible - * thus opening more room for internal optimzations. - */ - aiProcess_RemoveComponent = 0x10, - - // ------------------------------------------------------------------------- - /** <hr>Generates normals for all faces of all meshes. - * - * This is ignored if normals are already there at the time where this flag - * is evaluated. Model importers try to load them from the source file, so - * they're usually already there. Face normals are shared between all points - * of a single face, so a single point can have multiple normals, which in - * other words, enforces the library to duplicate vertices in some cases. - * #aiProcess_JoinIdenticalVertices is *senseless* then. - * - * This flag may not be specified together with #aiProcess_GenSmoothNormals. - */ - aiProcess_GenNormals = 0x20, - - // ------------------------------------------------------------------------- - /** <hr>Generates smooth normals for all vertices in the mesh. - * - * This is ignored if normals are already there at the time where this flag - * is evaluated. Model importers try to load them from the source file, so - * they're usually already there. - * - * This flag may (of course) not be specified together with - * #aiProcess_GenNormals. There's a configuration option, - * <tt>#AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE</tt> which allows you to specify - * an angle maximum for the normal smoothing algorithm. Normals exceeding - * this limit are not smoothed, resulting in a a 'hard' seam between two faces. - * Using a decent angle here (e.g. 80�) results in very good visual - * appearance. - */ - aiProcess_GenSmoothNormals = 0x40, - - // ------------------------------------------------------------------------- - /** <hr>Splits large meshes into smaller submeshes - * - * This is quite useful for realtime rendering where the number of triangles - * which can be maximally processed in a single draw-call is usually limited - * by the video driver/hardware. The maximum vertex buffer is usually limited, - * too. Both requirements can be met with this step: you may specify both a - * triangle and vertex limit for a single mesh. - * - * The split limits can (and should!) be set through the - * <tt>#AI_CONFIG_PP_SLM_VERTEX_LIMIT</tt> and <tt>#AI_CONFIG_PP_SLM_TRIANGLE_LIMIT</tt> - * settings. The default values are <tt>#AI_SLM_DEFAULT_MAX_VERTICES</tt> and - * <tt>#AI_SLM_DEFAULT_MAX_TRIANGLES</tt>. - * - * Note that splitting is generally a time-consuming task, but not if there's - * nothing to split. The use of this step is recommended for most users. - */ - aiProcess_SplitLargeMeshes = 0x80, - - // ------------------------------------------------------------------------- - /** <hr>Removes the node graph and pre-transforms all vertices with - * the local transformation matrices of their nodes. The output - * scene does still contain nodes, however, there is only a - * root node with children, each one referencing only one mesh, - * each mesh referencing one material. For rendering, you can - * simply render all meshes in order, you don't need to pay - * attention to local transformations and the node hierarchy. - * Animations are removed during this step. - * This step is intended for applications without a scenegraph. - * The step CAN cause some problems: if e.g. a mesh of the asset - * contains normals and another, using the same material index, does not, - * they will be brought together, but the first meshes's part of - * the normal list is zeroed. However, these artifacts are rare. - * @note The <tt>#AI_CONFIG_PP_PTV_NORMALIZE</tt> configuration property - * can be set to normalize the scene's spatial dimension to the -1...1 - * range. - */ - aiProcess_PreTransformVertices = 0x100, - - // ------------------------------------------------------------------------- - /** <hr>Limits the number of bones simultaneously affecting a single vertex - * to a maximum value. - * - * If any vertex is affected by more than that number of bones, the least - * important vertex weights are removed and the remaining vertex weights are - * renormalized so that the weights still sum up to 1. - * The default bone weight limit is 4 (defined as <tt>#AI_LMW_MAX_WEIGHTS</tt> in - * aiConfig.h), but you can use the <tt>#AI_CONFIG_PP_LBW_MAX_WEIGHTS</tt> setting to - * supply your own limit to the post processing step. - * - * If you intend to perform the skinning in hardware, this post processing - * step might be of interest for you. - */ - aiProcess_LimitBoneWeights = 0x200, - - // ------------------------------------------------------------------------- - /** <hr>Validates the imported scene data structure - * This makes sure that all indices are valid, all animations and - * bones are linked correctly, all material references are correct .. etc. - * - * It is recommended to capture Assimp's log output if you use this flag, - * so you can easily find ot what's actually wrong if a file fails the - * validation. The validator is quite rude and will find *all* - * inconsistencies in the data structure ... plugin developers are - * recommended to use it to debug their loaders. There are two types of - * validation failures: - * <ul> - * <li>Error: There's something wrong with the imported data. Further - * postprocessing is not possible and the data is not usable at all. - * The import fails. #Importer::GetErrorString() or #aiGetErrorString() - * carry the error message around.</li> - * <li>Warning: There are some minor issues (e.g. 1000000 animation - * keyframes with the same time), but further postprocessing and use - * of the data structure is still safe. Warning details are written - * to the log file, <tt>#AI_SCENE_FLAGS_VALIDATION_WARNING</tt> is set - * in #aiScene::mFlags</li> - * </ul> - * - * This post-processing step is not time-consuming. It's use is not - * compulsory, but recommended. - */ - aiProcess_ValidateDataStructure = 0x400, - - // ------------------------------------------------------------------------- - /** <hr>Reorders triangles for better vertex cache locality. - * - * The step tries to improve the ACMR (average post-transform vertex cache - * miss ratio) for all meshes. The implementation runs in O(n) and is - * roughly based on the 'tipsify' algorithm (see <a href="http://code.qt.io/%3C/div%3E%3Cdiv%20class='del'>- * http://www.cs.princeton.edu/gfx/pubs/Sander_2007_%3ETR/tipsy.pdf">this - * paper</a>). - * - * If you intend to render huge models in hardware, this step might - * be of interest for you. The <tt>#AI_CONFIG_PP_ICL_PTCACHE_SIZE</tt>config - * setting can be used to fine-tune the cache optimization. - */ - aiProcess_ImproveCacheLocality = 0x800, - - // ------------------------------------------------------------------------- - /** <hr>Searches for redundant/unreferenced materials and removes them. - * - * This is especially useful in combination with the - * #aiProcess_PretransformVertices and #aiProcess_OptimizeMeshes flags. - * Both join small meshes with equal characteristics, but they can't do - * their work if two meshes have different materials. Because several - * material settings are always lost during Assimp's import filters, - * (and because many exporters don't check for redundant materials), huge - * models often have materials which are are defined several times with - * exactly the same settings .. - * - * Several material settings not contributing to the final appearance of - * a surface are ignored in all comparisons ... the material name is - * one of them. So, if you're passing additional information through the - * content pipeline (probably using *magic* material names), don't - * specify this flag. Alternatively take a look at the - * <tt>#AI_CONFIG_PP_RRM_EXCLUDE_LIST</tt> setting. - */ - aiProcess_RemoveRedundantMaterials = 0x1000, - - // ------------------------------------------------------------------------- - /** <hr>This step tries to determine which meshes have normal vectors - * that are facing inwards. The algorithm is simple but effective: - * the bounding box of all vertices + their normals is compared against - * the volume of the bounding box of all vertices without their normals. - * This works well for most objects, problems might occur with planar - * surfaces. However, the step tries to filter such cases. - * The step inverts all in-facing normals. Generally it is recommended - * to enable this step, although the result is not always correct. - */ - aiProcess_FixInfacingNormals = 0x2000, - - // ------------------------------------------------------------------------- - /** <hr>This step splits meshes with more than one primitive type in - * homogeneous submeshes. - * - * The step is executed after the triangulation step. After the step - * returns, just one bit is set in aiMesh::mPrimitiveTypes. This is - * especially useful for real-time rendering where point and line - * primitives are often ignored or rendered separately. - * You can use the <tt>#AI_CONFIG_PP_SBP_REMOVE</tt> option to specify which - * primitive types you need. This can be used to easily exclude - * lines and points, which are rarely used, from the import. - */ - aiProcess_SortByPType = 0x8000, - - // ------------------------------------------------------------------------- - /** <hr>This step searches all meshes for degenerated primitives and - * converts them to proper lines or points. - * - * A face is 'degenerated' if one or more of its points are identical. - * To have the degenerated stuff not only detected and collapsed but - * also removed, try one of the following procedures: - * <br><b>1.</b> (if you support lines&points for rendering but don't - * want the degenerates)</br> - * <ul> - * <li>Specify the #aiProcess_FindDegenerates flag. - * </li> - * <li>Set the <tt>AI_CONFIG_PP_FD_REMOVE</tt> option to 1. This will - * cause the step to remove degenerated triangles from the import - * as soon as they're detected. They won't pass any further - * pipeline steps. - * </li> - * </ul> - * <br><b>2.</b>(if you don't support lines&points at all ...)</br> - * <ul> - * <li>Specify the #aiProcess_FindDegenerates flag. - * </li> - * <li>Specify the #aiProcess_SortByPType flag. This moves line and - * point primitives to separate meshes. - * </li> - * <li>Set the <tt>AI_CONFIG_PP_SBP_REMOVE</tt> option to - * @code aiPrimitiveType_POINTS | aiPrimitiveType_LINES - * @endcode to cause SortByPType to reject point - * and line meshes from the scene. - * </li> - * </ul> - * @note Degenerated polygons are not necessarily evil and that's why - * they're not removed by default. There are several file formats which - * don't support lines or points ... some exporters bypass the - * format specification and write them as degenerated triangle instead. - */ - aiProcess_FindDegenerates = 0x10000, - - // ------------------------------------------------------------------------- - /** <hr>This step searches all meshes for invalid data, such as zeroed - * normal vectors or invalid UV coords and removes/fixes them. This is - * intended to get rid of some common exporter errors. - * - * This is especially useful for normals. If they are invalid, and - * the step recognizes this, they will be removed and can later - * be recomputed, i.e. by the #aiProcess_GenSmoothNormals flag.<br> - * The step will also remove meshes that are infinitely small and reduce - * animation tracks consisting of hundreds if redundant keys to a single - * key. The <tt>AI_CONFIG_PP_FID_ANIM_ACCURACY</tt> config property decides - * the accuracy of the check for duplicate animation tracks. - */ - aiProcess_FindInvalidData = 0x20000, - - // ------------------------------------------------------------------------- - /** <hr>This step converts non-UV mappings (such as spherical or - * cylindrical mapping) to proper texture coordinate channels. - * - * Most applications will support UV mapping only, so you will - * probably want to specify this step in every case. Note tha Assimp is not - * always able to match the original mapping implementation of the - * 3d app which produced a model perfectly. It's always better to let the - * father app compute the UV channels, at least 3ds max, maja, blender, - * lightwave, modo, ... are able to achieve this. - * - * @note If this step is not requested, you'll need to process the - * <tt>#AI_MATKEY_MAPPING</tt> material property in order to display all assets - * properly. - */ - aiProcess_GenUVCoords = 0x40000, - - // ------------------------------------------------------------------------- - /** <hr>This step applies per-texture UV transformations and bakes - * them to stand-alone vtexture coordinate channelss. - * - * UV transformations are specified per-texture - see the - * <tt>#AI_MATKEY_UVTRANSFORM</tt> material key for more information. - * This step processes all textures with - * transformed input UV coordinates and generates new (pretransformed) UV channel - * which replace the old channel. Most applications won't support UV - * transformations, so you will probably want to specify this step. - * - * @note UV transformations are usually implemented in realtime apps by - * transforming texture coordinates at vertex shader stage with a 3x3 - * (homogenous) transformation matrix. - */ - aiProcess_TransformUVCoords = 0x80000, - - // ------------------------------------------------------------------------- - /** <hr>This step searches for duplicate meshes and replaces duplicates - * with references to the first mesh. - * - * This step takes a while, don't use it if you have no time. - * Its main purpose is to workaround the limitation that many export - * file formats don't support instanced meshes, so exporters need to - * duplicate meshes. This step removes the duplicates again. Please - * note that Assimp does currently not support per-node material - * assignment to meshes, which means that identical meshes with - * differnent materials are currently *not* joined, although this is - * planned for future versions. - */ - aiProcess_FindInstances = 0x100000, - - // ------------------------------------------------------------------------- - /** <hr>A postprocessing step to reduce the number of meshes. - * - * In fact, it will reduce the number of drawcalls. - * - * This is a very effective optimization and is recommended to be used - * together with #aiProcess_OptimizeGraph, if possible. The flag is fully - * compatible with both #aiProcess_SplitLargeMeshes and #aiProcess_SortByPType. - */ - aiProcess_OptimizeMeshes = 0x200000, - - - // ------------------------------------------------------------------------- - /** <hr>A postprocessing step to optimize the scene hierarchy. - * - * Nodes with no animations, bones, lights or cameras assigned are - * collapsed and joined. - * - * Node names can be lost during this step. If you use special 'tag nodes' - * to pass additional information through your content pipeline, use the - * <tt>#AI_CONFIG_PP_OG_EXCLUDE_LIST</tt> setting to specify a list of node - * names you want to be kept. Nodes matching one of the names in this list won't - * be touched or modified. - * - * Use this flag with caution. Most simple files will be collapsed to a - * single node, complex hierarchies are usually completely lost. That's not - * the right choice for editor environments, but probably a very effective - * optimization if you just want to get the model data, convert it to your - * own format and render it as fast as possible. - * - * This flag is designed to be used with #aiProcess_OptimizeMeshes for best - * results. - * - * @note 'crappy' scenes with thousands of extremely small meshes packed - * in deeply nested nodes exist for almost all file formats. - * #aiProcess_OptimizeMeshes in combination with #aiProcess_OptimizeGraph - * usually fixes them all and makes them renderable. - */ - aiProcess_OptimizeGraph = 0x400000, - - // ------------------------------------------------------------------------- - /** <hr>This step flips all UV coordinates along the y-axis and adjusts - * material settings and bitangents accordingly. - * <br><b>Output UV coordinate system:</b> - * @code - * 0y|0y ---------- 1x|0y - * | | - * | | - * | | - * 0x|1y ---------- 1x|1y - * @endcode - * - * You'll probably want to consider this flag if you use Direct3D for - * rendering. The #aiProcess_ConvertToLeftHanded flag supersedes this - * setting and bundles all conversions typically required for D3D-based - * applications. - */ - aiProcess_FlipUVs = 0x800000, - - // ------------------------------------------------------------------------- - /** <hr>This step adjusts the output face winding order to be cw. - * - * The default face winding order is counter clockwise. - * <br><b>Output face order:</b> - * @code - * x2 - * - * x0 - * x1 - * @endcode - */ - aiProcess_FlipWindingOrder = 0x1000000 - - // aiProcess_GenEntityMeshes = 0x100000, - // aiProcess_OptimizeAnimations = 0x200000 - // aiProcess_FixTexturePaths = 0x200000 -}; - - -// --------------------------------------------------------------------------------------- -/** @def aiProcess_ConvertToLeftHanded - * @brief Shortcut flag for Direct3D-based applications. - * - * Supersedes the #aiProcess_MakeLeftHanded and #aiProcess_FlipUVs and - * #aiProcess_FlipWindingOrder flags. - * The output data matches Direct3D's conventions: left-handed geometry, upper-left - * origin for UV coordinates and finally clockwise face order, suitable for CCW culling. - * - * @deprecated - */ -#define aiProcess_ConvertToLeftHanded ( \ - aiProcess_MakeLeftHanded | \ - aiProcess_FlipUVs | \ - aiProcess_FlipWindingOrder | \ - 0 ) - - -// --------------------------------------------------------------------------------------- -/** @def aiProcessPreset_TargetRealtimeUse_Fast - * @brief Default postprocess configuration optimizing the data for real-time rendering. - * - * Applications would want to use this preset to load models on end-user PCs, - * maybe for direct use in game. - * - * If you're using DirectX, don't forget to combine this value with - * the #aiProcess_ConvertToLeftHanded step. If you don't support UV transformations - * in your application apply the #aiProcess_TransformUVCoords step, too. - * @note Please take the time to read the doc to the steps enabled by this preset. - * Some of them offer further configurable properties, some of them might not be of - * use for you so it might be better to not specify them. - */ -#define aiProcessPreset_TargetRealtime_Fast ( \ - aiProcess_CalcTangentSpace | \ - aiProcess_GenNormals | \ - aiProcess_JoinIdenticalVertices | \ - aiProcess_Triangulate | \ - aiProcess_GenUVCoords | \ - aiProcess_SortByPType | \ - 0 ) - - // --------------------------------------------------------------------------------------- - /** @def aiProcessPreset_TargetRealtime_Quality - * @brief Default postprocess configuration optimizing the data for real-time rendering. - * - * Unlike #aiProcessPreset_TargetRealtime_Fast, this configuration - * performs some extra optimizations to improve rendering speed and - * to minimize memory usage. It could be a good choice for a level editor - * environment where import speed is not so important. - * - * If you're using DirectX, don't forget to combine this value with - * the #aiProcess_ConvertToLeftHanded step. If you don't support UV transformations - * in your application apply the #aiProcess_TransformUVCoords step, too. - * @note Please take the time to read the doc for the steps enabled by this preset. - * Some of them offer further configurable properties, some of them might not be of - * use for you so it might be better to not specify them. - */ -#define aiProcessPreset_TargetRealtime_Quality ( \ - aiProcess_CalcTangentSpace | \ - aiProcess_GenSmoothNormals | \ - aiProcess_JoinIdenticalVertices | \ - aiProcess_ImproveCacheLocality | \ - aiProcess_LimitBoneWeights | \ - aiProcess_RemoveRedundantMaterials | \ - aiProcess_SplitLargeMeshes | \ - aiProcess_Triangulate | \ - aiProcess_GenUVCoords | \ - aiProcess_SortByPType | \ - aiProcess_FindDegenerates | \ - aiProcess_FindInvalidData | \ - 0 ) - - // --------------------------------------------------------------------------------------- - /** @def aiProcessPreset_TargetRealtime_MaxQuality - * @brief Default postprocess configuration optimizing the data for real-time rendering. - * - * This preset enables almost every optimization step to achieve perfectly - * optimized data. It's your choice for level editor environments where import speed - * is not important. - * - * If you're using DirectX, don't forget to combine this value with - * the #aiProcess_ConvertToLeftHanded step. If you don't support UV transformations - * in your application, apply the #aiProcess_TransformUVCoords step, too. - * @note Please take the time to read the doc for the steps enabled by this preset. - * Some of them offer further configurable properties, some of them might not be of - * use for you so it might be better to not specify them. - */ -#define aiProcessPreset_TargetRealtime_MaxQuality ( \ - aiProcessPreset_TargetRealtime_Quality | \ - aiProcess_FindInstances | \ - aiProcess_ValidateDataStructure | \ - aiProcess_OptimizeMeshes | \ - 0 ) - - -#ifdef __cplusplus -} // end of extern "C" -#endif - -#endif // AI_POSTPROCESS_H_INC diff --git a/3rdparty/assimp/include/aiQuaternion.h b/3rdparty/assimp/include/aiQuaternion.h deleted file mode 100644 index 790cd060..00000000 --- a/3rdparty/assimp/include/aiQuaternion.h +++ /dev/null @@ -1,311 +0,0 @@ -/* -Open Asset Import Library (ASSIMP) ----------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ - -/** @file aiQuaternion.h - * @brief Quaternion structure, including operators when compiling in C++ - */ -#ifndef AI_QUATERNION_H_INC -#define AI_QUATERNION_H_INC - -#include <math.h> -#include "aiTypes.h" - -#ifdef __cplusplus -extern "C" { -#endif - -// --------------------------------------------------------------------------- -/** Represents a quaternion in a 4D vector. */ -struct aiQuaternion -{ -#ifdef __cplusplus - aiQuaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) {} - aiQuaternion(float _w, float _x, float _y, float _z) : w(_w), x(_x), y(_y), z(_z) {} - - /** Construct from rotation matrix. Result is undefined if the matrix is not orthonormal. */ - aiQuaternion( const aiMatrix3x3& pRotMatrix); - - /** Construct from euler angles */ - aiQuaternion( float rotx, float roty, float rotz); - - /** Construct from an axis-angle pair */ - aiQuaternion( aiVector3D axis, float angle); - - /** Construct from a normalized quaternion stored in a vec3 */ - aiQuaternion( aiVector3D normalized); - - /** Returns a matrix representation of the quaternion */ - aiMatrix3x3 GetMatrix() const; - - - bool operator== (const aiQuaternion& o) const - {return x == o.x && y == o.y && z == o.z && w == o.w;} - - bool operator!= (const aiQuaternion& o) const - {return !(*this == o);} - - /** Normalize the quaternion */ - aiQuaternion& Normalize(); - - /** Compute quaternion conjugate */ - aiQuaternion& Conjugate (); - - /** Rotate a point by this quaternion */ - aiVector3D Rotate (const aiVector3D& in); - - /** Multiply two quaternions */ - aiQuaternion operator* (const aiQuaternion& two) const; - - /** Performs a spherical interpolation between two quaternions and writes the result into the third. - * @param pOut Target object to received the interpolated rotation. - * @param pStart Start rotation of the interpolation at factor == 0. - * @param pEnd End rotation, factor == 1. - * @param pFactor Interpolation factor between 0 and 1. Values outside of this range yield undefined results. - */ - static void Interpolate( aiQuaternion& pOut, const aiQuaternion& pStart, const aiQuaternion& pEnd, float pFactor); - -#endif // __cplusplus - - //! w,x,y,z components of the quaternion - float w, x, y, z; -} ; - - -#ifdef __cplusplus - -// --------------------------------------------------------------------------- -// Constructs a quaternion from a rotation matrix -inline aiQuaternion::aiQuaternion( const aiMatrix3x3 &pRotMatrix) -{ - float t = 1 + pRotMatrix.a1 + pRotMatrix.b2 + pRotMatrix.c3; - - // large enough - if ( t > 0.001f) - { - float s = sqrt( t) * 2.0f; - x = (pRotMatrix.c2 - pRotMatrix.b3) / s; - y = (pRotMatrix.a3 - pRotMatrix.c1) / s; - z = (pRotMatrix.b1 - pRotMatrix.a2) / s; - w = 0.25f * s; - } // else we have to check several cases - else if ( pRotMatrix.a1 > pRotMatrix.b2 && pRotMatrix.a1 > pRotMatrix.c3 ) - { - // Column 0: - float s = sqrt( 1.0f + pRotMatrix.a1 - pRotMatrix.b2 - pRotMatrix.c3) * 2.0f; - x = 0.25f * s; - y = (pRotMatrix.b1 + pRotMatrix.a2) / s; - z = (pRotMatrix.a3 + pRotMatrix.c1) / s; - w = (pRotMatrix.c2 - pRotMatrix.b3) / s; - } - else if ( pRotMatrix.b2 > pRotMatrix.c3) - { - // Column 1: - float s = sqrt( 1.0f + pRotMatrix.b2 - pRotMatrix.a1 - pRotMatrix.c3) * 2.0f; - x = (pRotMatrix.b1 + pRotMatrix.a2) / s; - y = 0.25f * s; - z = (pRotMatrix.c2 + pRotMatrix.b3) / s; - w = (pRotMatrix.a3 - pRotMatrix.c1) / s; - } else - { - // Column 2: - float s = sqrt( 1.0f + pRotMatrix.c3 - pRotMatrix.a1 - pRotMatrix.b2) * 2.0f; - x = (pRotMatrix.a3 + pRotMatrix.c1) / s; - y = (pRotMatrix.c2 + pRotMatrix.b3) / s; - z = 0.25f * s; - w = (pRotMatrix.b1 - pRotMatrix.a2) / s; - } -} - -// --------------------------------------------------------------------------- -// Construction from euler angles -inline aiQuaternion::aiQuaternion( float fPitch, float fYaw, float fRoll ) -{ - const float fSinPitch(sin(fPitch*0.5F)); - const float fCosPitch(cos(fPitch*0.5F)); - const float fSinYaw(sin(fYaw*0.5F)); - const float fCosYaw(cos(fYaw*0.5F)); - const float fSinRoll(sin(fRoll*0.5F)); - const float fCosRoll(cos(fRoll*0.5F)); - const float fCosPitchCosYaw(fCosPitch*fCosYaw); - const float fSinPitchSinYaw(fSinPitch*fSinYaw); - x = fSinRoll * fCosPitchCosYaw - fCosRoll * fSinPitchSinYaw; - y = fCosRoll * fSinPitch * fCosYaw + fSinRoll * fCosPitch * fSinYaw; - z = fCosRoll * fCosPitch * fSinYaw - fSinRoll * fSinPitch * fCosYaw; - w = fCosRoll * fCosPitchCosYaw + fSinRoll * fSinPitchSinYaw; -} - -// --------------------------------------------------------------------------- -// Returns a matrix representation of the quaternion -inline aiMatrix3x3 aiQuaternion::GetMatrix() const -{ - aiMatrix3x3 resMatrix; - resMatrix.a1 = 1.0f - 2.0f * (y * y + z * z); - resMatrix.a2 = 2.0f * (x * y - z * w); - resMatrix.a3 = 2.0f * (x * z + y * w); - resMatrix.b1 = 2.0f * (x * y + z * w); - resMatrix.b2 = 1.0f - 2.0f * (x * x + z * z); - resMatrix.b3 = 2.0f * (y * z - x * w); - resMatrix.c1 = 2.0f * (x * z - y * w); - resMatrix.c2 = 2.0f * (y * z + x * w); - resMatrix.c3 = 1.0f - 2.0f * (x * x + y * y); - - return resMatrix; -} - -// --------------------------------------------------------------------------- -// Construction from an axis-angle pair -inline aiQuaternion::aiQuaternion( aiVector3D axis, float angle) -{ - axis.Normalize(); - - const float sin_a = sin( angle / 2 ); - const float cos_a = cos( angle / 2 ); - x = axis.x * sin_a; - y = axis.y * sin_a; - z = axis.z * sin_a; - w = cos_a; -} -// --------------------------------------------------------------------------- -// Construction from am existing, normalized quaternion -inline aiQuaternion::aiQuaternion( aiVector3D normalized) -{ - x = normalized.x; - y = normalized.y; - z = normalized.z; - - const float t = 1.0f - (x*x) - (y*y) - (z*z); - - if (t < 0.0f) - w = 0.0f; - else w = sqrt (t); -} - -// --------------------------------------------------------------------------- -// Performs a spherical interpolation between two quaternions -// Implementation adopted from the gmtl project. All others I found on the net fail in some cases. -// Congrats, gmtl! -inline void aiQuaternion::Interpolate( aiQuaternion& pOut, const aiQuaternion& pStart, const aiQuaternion& pEnd, float pFactor) -{ - // calc cosine theta - float cosom = pStart.x * pEnd.x + pStart.y * pEnd.y + pStart.z * pEnd.z + pStart.w * pEnd.w; - - // adjust signs (if necessary) - aiQuaternion end = pEnd; - if ( cosom < 0.0f) - { - cosom = -cosom; - end.x = -end.x; // Reverse all signs - end.y = -end.y; - end.z = -end.z; - end.w = -end.w; - } - - // Calculate coefficients - float sclp, sclq; - if ( (1.0f - cosom) > 0.0001f) // 0.0001 -> some epsillon - { - // Standard case (slerp) - float omega, sinom; - omega = acos( cosom); // extract theta from dot product's cos theta - sinom = sin( omega); - sclp = sin( (1.0f - pFactor) * omega) / sinom; - sclq = sin( pFactor * omega) / sinom; - } else - { - // Very close, do linear interp (because it's faster) - sclp = 1.0f - pFactor; - sclq = pFactor; - } - - pOut.x = sclp * pStart.x + sclq * end.x; - pOut.y = sclp * pStart.y + sclq * end.y; - pOut.z = sclp * pStart.z + sclq * end.z; - pOut.w = sclp * pStart.w + sclq * end.w; -} - -// --------------------------------------------------------------------------- -inline aiQuaternion& aiQuaternion::Normalize() -{ - // compute the magnitude and divide through it - const float mag = x*x+y*y+z*z+w*w; - if (mag) - { - x /= mag; - y /= mag; - z /= mag; - w /= mag; - } - return *this; -} - -// --------------------------------------------------------------------------- -inline aiQuaternion aiQuaternion::operator* (const aiQuaternion& t) const -{ - return aiQuaternion(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.y + y*t.w + z*t.x - x*t.z, - w*t.z + z*t.w + x*t.y - y*t.x); -} - -// --------------------------------------------------------------------------- -inline aiQuaternion& aiQuaternion::Conjugate () -{ - x = -x; - y = -y; - z = -z; - return *this; -} - -// --------------------------------------------------------------------------- -inline aiVector3D aiQuaternion::Rotate (const aiVector3D& v) -{ - aiQuaternion q2(0.f,v.x,v.y,v.z), q = *this, qinv = q; - q.Conjugate(); - - q = q*q2*qinv; - return aiVector3D(q.x,q.y,q.z); - -} - -} // end extern "C" - -#endif // __cplusplus - -#endif // AI_QUATERNION_H_INC diff --git a/3rdparty/assimp/include/aiScene.h b/3rdparty/assimp/include/aiScene.h deleted file mode 100644 index 6c4b4900..00000000 --- a/3rdparty/assimp/include/aiScene.h +++ /dev/null @@ -1,417 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiScene.h - * @brief Defines the data structures in which the imported scene is returned. - */ -#ifndef __AI_SCENE_H_INC__ -#define __AI_SCENE_H_INC__ - -#include "aiTypes.h" -#include "aiTexture.h" -#include "aiMesh.h" -#include "aiLight.h" -#include "aiCamera.h" -#include "aiMaterial.h" -#include "aiAnim.h" - -#ifdef __cplusplus -extern "C" { -#endif - -// ------------------------------------------------------------------------------- -/** A node in the imported hierarchy. - * - * Each node has name, a parent node (except for the root node), - * a transformation relative to its parent and possibly several child nodes. - * Simple file formats don't support hierarchical structures - for these formats - * the imported scene does consist of only a single root node without children. - */ -// ------------------------------------------------------------------------------- -struct aiNode -{ - /** The name of the node. - * - * The name might be empty (length of zero) but all nodes which - * need to be accessed afterwards by bones or anims are usually named. - * Multiple nodes may have the same name, but nodes which are accessed - * by bones (see #aiBone and #aiMesh::mBones) *must* be unique. - * - * Cameras and lights are assigned to a specific node name - if there - * are multiple nodes with this name, they're assigned to each of them. - * <br> - * There are no limitations regarding the characters contained in - * this text. You should be able to handle stuff like whitespace, tabs, - * linefeeds, quotation marks, ampersands, ... . - */ - C_STRUCT aiString mName; - - /** The transformation relative to the node's parent. */ - C_STRUCT aiMatrix4x4 mTransformation; - - /** Parent node. NULL if this node is the root node. */ - C_STRUCT aiNode* mParent; - - /** The number of child nodes of this node. */ - unsigned int mNumChildren; - - /** The child nodes of this node. NULL if mNumChildren is 0. */ - C_STRUCT aiNode** mChildren; - - /** The number of meshes of this node. */ - unsigned int mNumMeshes; - - /** The meshes of this node. Each entry is an index into the mesh */ - unsigned int* mMeshes; - -#ifdef __cplusplus - /** Constructor */ - aiNode() - { - // set all members to zero by default - mParent = NULL; - mNumChildren = 0; mChildren = NULL; - mNumMeshes = 0; mMeshes = NULL; - } - - /** Construction from a specific name */ - aiNode(const std::string& name) - { - // set all members to zero by default - mParent = NULL; - mNumChildren = 0; mChildren = NULL; - mNumMeshes = 0; mMeshes = NULL; - mName = name; - } - - /** Destructor */ - ~aiNode() - { - // delete all children recursively - // to make sure we won't crash if the data is invalid ... - if (mChildren && mNumChildren) - { - for ( unsigned int a = 0; a < mNumChildren; a++) - delete mChildren[a]; - } - delete [] mChildren; - delete [] mMeshes; - } - - /** Searches for a node with a specific name, beginning at this - * nodes. Normally you will call this method on the root node - * of the scene. - * - * @param name Name to search for - * @return NULL or a valid Node if the search was successful. - */ - inline aiNode* FindNode(const aiString& name) - { - return FindNode(name.data); - } - - /** @override - */ - inline aiNode* FindNode(const char* name) - { - if (!::strcmp( mName.data,name))return this; - for (unsigned int i = 0; i < mNumChildren;++i) - { - aiNode* p = mChildren[i]->FindNode(name); - if (p)return p; - } - // there is definitely no sub node with this name - return NULL; - } - -#endif // __cplusplus -}; - - -// ------------------------------------------------------------------------------- -/** @def AI_SCENE_FLAGS_INCOMPLETE - * Specifies that the scene data structure that was imported is not complete. - * This flag bypasses some internal validations and allows the import - * of animation skeletons, material libraries or camera animation paths - * using Assimp. Most applications won't support such data. - */ -#define AI_SCENE_FLAGS_INCOMPLETE 0x1 - -/** @def AI_SCENE_FLAGS_VALIDATED - * 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 - * any cross references in the data structure (e.g. vertex indices) are valid. - */ -#define AI_SCENE_FLAGS_VALIDATED 0x2 - -/** @def AI_SCENE_FLAGS_VALIDATION_WARNING - * This flag is set by the validation postprocess-step (aiPostProcess_ValidateDS) - * 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 - * 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 - * be useful for applications which don't capture Assimp's log output. - */ -#define AI_SCENE_FLAGS_VALIDATION_WARNING 0x4 - -/** @def AI_SCENE_FLAGS_NON_VERBOSE_FORMAT - * 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 - * verbose format anymore. In the verbose format all vertices are unique, - * no vertex is ever referenced by more than one face. - */ -#define AI_SCENE_FLAGS_NON_VERBOSE_FORMAT 0x8 - - /** @def AI_SCENE_FLAGS_TERRAIN - * 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 - * positions refer to the x,y coordinates on the terrain height map, the z-axis - * stores the elevation at a specific point. - * - * TER (Terragen) and HMP (3D Game Studio) are height map formats. - * @note Assimp is probably not the best choice for loading *huge* terrains - - * 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 - * need to render it). - */ -#define AI_SCENE_FLAGS_TERRAIN 0x10 - - -// ------------------------------------------------------------------------------- -/** The root structure of the imported data. - * - * 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 - * by the caller. You shouldn't want to instance it, nor should you ever try to - * delete a given scene on your own. - */ -// ------------------------------------------------------------------------------- -struct aiScene -{ - - /** Any combination of the AI_SCENE_FLAGS_XXX flags. By default - * this value is 0, no flags are set. Most applications will - * want to reject all scenes with the AI_SCENE_FLAGS_INCOMPLETE - * bit set. - */ - unsigned int mFlags; - - - /** The root node of the hierarchy. - * - * There will always be at least the root node if the import - * was successful (and no special flags have been set). - * Presence of further nodes depends on the format and content - * of the imported file. - */ - C_STRUCT aiNode* mRootNode; - - - - /** The number of meshes in the scene. */ - unsigned int mNumMeshes; - - /** The array of meshes. - * - * Use the indices given in the aiNode structure to access - * this array. The array is mNumMeshes in size. If the - * AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always - * be at least ONE material. - */ - C_STRUCT aiMesh** mMeshes; - - - - /** The number of materials in the scene. */ - unsigned int mNumMaterials; - - /** The array of materials. - * - * Use the index given in each aiMesh structure to access this - * array. The array is mNumMaterials in size. If the - * AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always - * be at least ONE material. - */ - C_STRUCT aiMaterial** mMaterials; - - - - /** The number of animations in the scene. */ - unsigned int mNumAnimations; - - /** The array of animations. - * - * All animations imported from the given file are listed here. - * The array is mNumAnimations in size. - */ - C_STRUCT aiAnimation** mAnimations; - - - - /** The number of textures embedded into the file */ - unsigned int mNumTextures; - - /** The array of embedded textures. - * - * Not many file formats embed their textures into the file. - * An example is Quake's MDL format (which is also used by - * some GameStudio versions) - */ - C_STRUCT aiTexture** mTextures; - - - /** The number of light sources in the scene. Light sources - * are fully optional, in most cases this attribute will be 0 - */ - unsigned int mNumLights; - - /** The array of light sources. - * - * All light sources imported from the given file are - * listed here. The array is mNumLights in size. - */ - C_STRUCT aiLight** mLights; - - - /** The number of cameras in the scene. Cameras - * are fully optional, in most cases this attribute will be 0 - */ - unsigned int mNumCameras; - - /** The array of cameras. - * - * All cameras imported from the given file are listed here. - * The array is mNumCameras in size. The first camera in the - * array (if existing) is the default camera view into - * the scene. - */ - C_STRUCT aiCamera** mCameras; - -#ifdef __cplusplus - - //! Default constructor - aiScene() - { - // set all members to zero by default - mRootNode = NULL; - mNumMeshes = 0; mMeshes = NULL; - mNumMaterials = 0; mMaterials = NULL; - mNumAnimations = 0; mAnimations = NULL; - mNumTextures = 0; mTextures = NULL; - mNumCameras = 0; mCameras = NULL; - mNumLights = 0; mLights = NULL; - mFlags = 0; - } - - //! Destructor - ~aiScene() - { - // delete all sub-objects recursively - delete mRootNode; - - // To make sure we won't crash if the data is invalid it's - // much better to check whether both mNumXXX and mXXX are - // valid instead of relying on just one of them. - if (mNumMeshes && mMeshes) - for ( unsigned int a = 0; a < mNumMeshes; a++) - delete mMeshes[a]; - delete [] mMeshes; - - if (mNumMaterials && mMaterials) - for ( unsigned int a = 0; a < mNumMaterials; a++) - delete mMaterials[a]; - delete [] mMaterials; - - if (mNumAnimations && mAnimations) - for ( unsigned int a = 0; a < mNumAnimations; a++) - delete mAnimations[a]; - delete [] mAnimations; - - if (mNumTextures && mTextures) - for ( unsigned int a = 0; a < mNumTextures; a++) - delete mTextures[a]; - delete [] mTextures; - - if (mNumLights && mLights) - for ( unsigned int a = 0; a < mNumLights; a++) - delete mLights[a]; - delete [] mLights; - - if (mNumCameras && mCameras) - for ( unsigned int a = 0; a < mNumCameras; a++) - delete mCameras[a]; - delete [] mCameras; - } - - //! Check whether the scene contains meshes - //! Unless no special scene flags are set this will always be true. - inline bool HasMeshes() const - { return mMeshes != NULL && mNumMeshes > 0; } - - //! Check whether the scene contains materials - //! Unless no special scene flags are set this will always be true. - inline bool HasMaterials() const - { return mMaterials != NULL && mNumMaterials > 0; } - - //! Check whether the scene contains lights - inline bool HasLights() const - { return mLights != NULL && mNumLights > 0; } - - //! Check whether the scene contains textures - inline bool HasTextures() const - { return mTextures != NULL && mNumTextures > 0; } - - //! Check whether the scene contains cameras - inline bool HasCameras() const - { return mCameras != NULL && mNumCameras > 0; } - - //! Check whether the scene contains animations - inline bool HasAnimations() const - { return mAnimations != NULL && mNumAnimations > 0; } - -#endif // __cplusplus -}; - -#ifdef __cplusplus -} //! namespace Assimp -#endif - -#endif // __AI_SCENE_H_INC__ diff --git a/3rdparty/assimp/include/aiTexture.h b/3rdparty/assimp/include/aiTexture.h deleted file mode 100644 index e64f0205..00000000 --- a/3rdparty/assimp/include/aiTexture.h +++ /dev/null @@ -1,198 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiTexture.h - * @brief Defines texture helper structures for the library - * - * Used for file formats which embed their textures into the model file. - * Supported are both normal textures, which are stored as uncompressed - * pixels, and "compressed" textures, which are stored in a file format - * such as PNG or TGA. - */ - -#ifndef AI_TEXTURE_H_INC -#define AI_TEXTURE_H_INC - -#include "aiTypes.h" - -#ifdef __cplusplus -extern "C" { -#endif - - -// -------------------------------------------------------------------------------- -/** @def AI_MAKE_EMBEDDED_TEXNAME - * Used to build the reserved path name used by the material system to - * reference textures that are embedded into their corresponding - * model files. The parameter specifies the index of the texture - * (zero-based, in the aiScene::mTextures array) - */ -#if (!defined AI_MAKE_EMBEDDED_TEXNAME) -# define AI_MAKE_EMBEDDED_TEXNAME(_n_) "*" # _n_ -#endif - - -#include "./Compiler/pushpack1.h" - -// -------------------------------------------------------------------------------- -/** @brief Helper structure to represent a texel in a ARGB8888 format -* -* Used by aiTexture. -*/ -struct aiTexel -{ - unsigned char b,g,r,a; - -#ifdef __cplusplus - //! Comparison operator - bool operator== (const aiTexel& other) const - { - return b == other.b && r == other.r && - g == other.g && a == other.a; - } - - //! Inverse comparison operator - bool operator!= (const aiTexel& other) const - { - return b != other.b || r != other.r || - g != other.g || a != other.a; - } - - //! Conversion to a floating-point 4d color - operator aiColor4D() const - { - return aiColor4D(r/255.f,g/255.f,b/255.f,a/255.f); - } -#endif // __cplusplus - -} PACK_STRUCT; - -#include "./Compiler/poppack1.h" - -// -------------------------------------------------------------------------------- -/** Helper structure to describe an embedded texture - * - * 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: - * 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 - * bytes are given so the application must utilize an image decoder (e.g. DevIL) to - * get access to the actual color data. - */ -struct aiTexture -{ - /** Width of the texture, in pixels - * - * If mHeight is zero the texture is compressed in a format - * like JPEG. In this case mWidth specifies the size of the - * memory area pcData is pointing to, in bytes. - */ - unsigned int mWidth; - - /** Height of the texture, in pixels - * - * If this value is zero, pcData points to an compressed texture - * in any format (e.g. JPEG). - */ - unsigned int mHeight; - - /** A hint from the loader to make it easier for applications - * to determine the type of embedded compressed textures. - * - * If mHeight != 0 this member is undefined. Otherwise it - * is set set to '\\0\\0\\0\\0' if the loader has no additional - * information about the texture file format used OR the - * file extension of the format without a trailing dot. If there - * are multiple file extensions for a format, the shortest - * extension is chosen (JPEG maps to 'jpg', not to 'jpeg'). - * E.g. 'dds\\0', 'pcx\\0', 'jpg\\0'. All characters are lower-case. - * The fourth character will always be '\\0'. - */ - char achFormatHint[4]; - - /** Data of the texture. - * - * Points to an array of mWidth * mHeight aiTexel's. - * The format of the texture data is always ARGB8888 to - * make the implementation for user of the library as easy - * as possible. If mHeight = 0 this is a pointer to a memory - * buffer of size mWidth containing the compressed texture - * data. Good luck, have fun! - */ - C_STRUCT aiTexel* pcData; - -#ifdef __cplusplus - - //! For compressed textures (mHeight == 0): compare the - //! format hint against a given string. - //! @param s Input string. 3 characters are maximally processed. - //! Example values: "jpg", "png" - //! @return true if the given string matches the format hint - bool CheckFormat(const char* s) const - { - ai_assert(s && !mHeight); - return (0 == ::strncmp(achFormatHint,s,3)); - } - - // Construction - aiTexture () - : mWidth (0) - , mHeight (0) - , pcData (NULL) - { - achFormatHint[0] = achFormatHint[1] = 0; - achFormatHint[2] = achFormatHint[3] = 0; - } - - // Destruction - ~aiTexture () - { - delete[] pcData; - } -#endif -}; - - -#ifdef __cplusplus -} -#endif - -#endif // AI_TEXTURE_H_INC diff --git a/3rdparty/assimp/include/aiTypes.h b/3rdparty/assimp/include/aiTypes.h deleted file mode 100644 index de956dad..00000000 --- a/3rdparty/assimp/include/aiTypes.h +++ /dev/null @@ -1,492 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiTypes.h - * Basic data types and primitives, such as vectors or colors. - */ -#ifndef AI_TYPES_H_INC -#define AI_TYPES_H_INC - -// Some runtime headers -#include <sys/types.h> -#include <memory.h> -#include <math.h> -#include <stddef.h> - -// Our compile configuration -#include "aiDefines.h" - -// Some types moved to separate header due to size of operators -#include "aiVector3D.h" -#include "aiVector2D.h" -#include "aiColor4D.h" -#include "aiMatrix3x3.h" -#include "aiMatrix4x4.h" -#include "aiQuaternion.h" - -#ifdef __cplusplus -#include <new> // for std::nothrow_t -#include <string> // for aiString::Set(const std::string&) - -namespace Assimp { - //! @cond never -namespace Intern { - // -------------------------------------------------------------------- - /** @brief Internal helper class to utilize our internal new/delete - * routines for allocating object of this and derived classes. - * - * By doing this you can safely share class objects between Assimp - * and the application - it works even over DLL boundaries. A good - * example is the #IOSystem where the application allocates its custom - * #IOSystem, then calls #Importer::SetIOSystem(). When the Importer - * destructs, Assimp calls operator delete on the stored #IOSystem. - * If it lies on a different heap than Assimp is working with, - * the application is determined to crash. - */ - // -------------------------------------------------------------------- -#ifndef SWIG - struct ASSIMP_API AllocateFromAssimpHeap { - // http://www.gotw.ca/publications/mill15.htm - - // new/delete overload - void *operator new ( size_t num_bytes) /* throw( std::bad_alloc ) */; - void *operator new ( size_t num_bytes, const std::nothrow_t& ) throw(); - void operator delete ( void* data); - - // array new/delete overload - void *operator new[] ( size_t num_bytes) /* throw( std::bad_alloc ) */; - void *operator new[] ( size_t num_bytes, const std::nothrow_t& ) throw(); - void operator delete[] ( void* data); - - }; // struct AllocateFromAssimpHeap -#endif -} // namespace Intern - //! @endcond -} // namespace Assimp - -extern "C" { -#endif - -/** Maximum dimension for strings, ASSIMP strings are zero terminated. */ -#ifdef __cplusplus -const size_t MAXLEN = 1024; -#else -# define MAXLEN 1024 -#endif - -#include "./Compiler/pushpack1.h" - -// ---------------------------------------------------------------------------------- -/** Represents a plane in a three-dimensional, euclidean space -*/ -struct aiPlane -{ -#ifdef __cplusplus - aiPlane () : a(0.f), b(0.f), c(0.f), d(0.f) {} - aiPlane (float _a, float _b, float _c, float _d) - : a(_a), b(_b), c(_c), d(_d) {} - - aiPlane (const aiPlane& o) : a(o.a), b(o.b), c(o.c), d(o.d) {} - -#endif // !__cplusplus - - //! Plane equation - float a,b,c,d; -} PACK_STRUCT; // !struct aiPlane - -// ---------------------------------------------------------------------------------- -/** Represents a ray -*/ -struct aiRay -{ -#ifdef __cplusplus - aiRay () {} - aiRay (const aiVector3D& _pos, const aiVector3D& _dir) - : pos(_pos), dir(_dir) {} - - aiRay (const aiRay& o) : pos (o.pos), dir (o.dir) {} - -#endif // !__cplusplus - - //! Position and direction of the ray - C_STRUCT aiVector3D pos, dir; -} PACK_STRUCT; // !struct aiRay - -// ---------------------------------------------------------------------------------- -/** Represents a color in Red-Green-Blue space. -*/ -struct aiColor3D -{ -#ifdef __cplusplus - aiColor3D () : r(0.0f), g(0.0f), b(0.0f) {} - aiColor3D (float _r, float _g, float _b) : r(_r), g(_g), b(_b) {} - aiColor3D (float _r) : r(_r), g(_r), b(_r) {} - aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {} - - /** Component-wise comparison */ - // TODO: add epsilon? - bool operator == (const aiColor3D& other) const - {return r == other.r && g == other.g && b == other.b;} - - /** Component-wise inverse comparison */ - // TODO: add epsilon? - bool operator != (const aiColor3D& other) const - {return r != other.r || g != other.g || b != other.b;} - - /** Component-wise addition */ - aiColor3D operator+(const aiColor3D& c) const { - return aiColor3D(r+c.r,g+c.g,b+c.b); - } - - /** Component-wise subtraction */ - aiColor3D operator-(const aiColor3D& c) const { - return aiColor3D(r+c.r,g+c.g,b+c.b); - } - - /** Component-wise multiplication */ - aiColor3D operator*(const aiColor3D& c) const { - return aiColor3D(r*c.r,g*c.g,b*c.b); - } - - /** Multiply with a scalar */ - aiColor3D operator*(float f) const { - return aiColor3D(r*f,g*f,b*f); - } - - /** Access a specific color component */ - float operator[](unsigned int i) const { - return *(&r + i); - } - - /** Access a specific color component */ - float& operator[](unsigned int i) { - return *(&r + i); - } - - /** Check whether a color is black */ - bool IsBlack() const { - static const float epsilon = 10e-3f; - return fabs( r ) < epsilon && fabs( g ) < epsilon && fabs( b ) < epsilon; - } - -#endif // !__cplusplus - - //! Red, green and blue color values - float r, g, b; -} PACK_STRUCT; // !struct aiColor3D -#include "./Compiler/poppack1.h" - -// ---------------------------------------------------------------------------------- -/** Represents an UTF-8 string, zero byte terminated. - * - * The character set of an aiString is explicitly defined to be UTF-8. This Unicode - * transformation was chosen in the belief that most strings in 3d files are limited - * to the ASCII characters, thus the character set needed to be ASCII compatible. - * - * Most text file loaders provide proper Unicode input file handling, special unicode - * characters are correctly transcoded to UTF8 and are kept throughout the libraries' - * import pipeline. - * - * For most applications, it will be absolutely sufficient to interpret the - * aiString as ASCII data and work with it as one would work with a plain char*. - * Windows users in need of proper support for i.e asian characters can use the - * #MultiByteToWideChar(), #WideCharToMultiByte() WinAPI functionality to convert the - * UTF-8 strings to their working character set (i.e. MBCS, WideChar). - * - * We use this representation instead of std::string to be C-compatible. The - * (binary) length of such a string is limited to MAXLEN characters (including the - * the terminating zero). -*/ -struct aiString -{ -#ifdef __cplusplus - /** Default constructor, the string is set to have zero length */ - aiString() : - length(0) - { - data[0] = '\0'; - -#ifdef _DEBUG - // Debug build: overwrite the string on its full length with ESC (27) - memset(data+1,27,MAXLEN-1); -#endif - } - - /** Copy constructor */ - aiString(const aiString& rOther) : - length(rOther.length) - { - // Crop the string to the maximum length - length = length>=MAXLEN?MAXLEN-1:length; - memcpy( data, rOther.data, length); - data[length] = '\0'; - } - - /** Constructor from std::string */ - aiString(const std::string& pString) : - length(pString.length()) - { - length = length>=MAXLEN?MAXLEN-1:length; - memcpy( data, pString.c_str(), length); - data[length] = '\0'; - } - - /** Copy a std::string to the aiString */ - void Set( const std::string& pString) { - if ( pString.length() > MAXLEN - 1) { - return; - } - length = pString.length(); - ::memcpy( data, pString.c_str(), length); - data[length] = 0; - } - - /** Copy a const char* to the aiString */ - void Set( const char* sz) { - const size_t len = ::strlen(sz); - if ( len > MAXLEN - 1) { - return; - } - length = len; - ::memcpy( data, sz, len); - data[len] = 0; - } - - /** Assign a const char* to the string */ - aiString& operator = (const char* sz) { - Set(sz); - return *this; - } - - /** Assign a cstd::string to the string */ - aiString& operator = ( const std::string& pString) { - Set(pString); - return *this; - } - - /** Comparison operator */ - bool operator==(const aiString& other) const { - return (length == other.length && 0 == strcmp(this->data,other.data)); - } - - /** Inverse comparison operator */ - bool operator!=(const aiString& other) const { - return (length != other.length || 0 != ::strcmp(this->data,other.data)); - } - - /** Append a string to the string */ - void Append (const char* app) { - const size_t len = ::strlen(app); - if (!len) { - return; - } - if (length + len >= MAXLEN) { - return; - } - - memcpy(&data[length],app,len+1); - length += len; - } - - /** Clear the string - reset its length to zero */ - void Clear () { - length = 0; - data[0] = '\0'; - -#ifdef _DEBUG - // Debug build: overwrite the string on its full length with ESC (27) - memset(data+1,27,MAXLEN-1); -#endif - } - -#endif // !__cplusplus - - /** Binary length of the string excluding the terminal 0. This is NOT the - * logical length of strings containing UTF-8 multibyte sequences! It's - * the number of bytes from the beginning of the string to its end.*/ - size_t length; - - /** String buffer. Size limit is MAXLEN */ - char data[MAXLEN]; -} ; // !struct aiString - - -// ---------------------------------------------------------------------------------- -/** Standard return type for some library functions. - * Rarely used, and if, mostly in the C API. - */ -enum aiReturn -{ - /** Indicates that a function was successful */ - aiReturn_SUCCESS = 0x0, - - /** Indicates that a function failed */ - aiReturn_FAILURE = -0x1, - - /** Indicates that not enough memory was available - * to perform the requested operation - */ - aiReturn_OUTOFMEMORY = -0x3, - - /** @cond never - * Force 32-bit size enum - */ - _AI_ENFORCE_ENUM_SIZE = 0x7fffffff -}; // !enum aiReturn - -// just for backwards compatibility, don't use these constants anymore -#define AI_SUCCESS aiReturn_SUCCESS -#define AI_FAILURE aiReturn_FAILURE -#define AI_OUTOFMEMORY aiReturn_OUTOFMEMORY - -// ---------------------------------------------------------------------------------- -/** Seek origins (for the virtual file system API). - * Much cooler than using SEEK_SET, SEEK_CUR or SEEK_END. - */ -enum aiOrigin -{ - /** Beginning of the file */ - aiOrigin_SET = 0x0, - - /** Current position of the file pointer */ - aiOrigin_CUR = 0x1, - - /** End of the file, offsets must be negative */ - aiOrigin_END = 0x2, - - /** @cond never - * Force 32-bit size enum - */ - _AI_ORIGIN_ENFORCE_ENUM_SIZE = 0x7fffffff -}; // !enum aiOrigin - -// ---------------------------------------------------------------------------------- -/** @brief Enumerates predefined log streaming destinations. - * Logging to these streams can be enabled with a single call to - * #LogStream::createDefaultStream or #aiAttachPredefinedLogStream(), - * respectively. - */ -enum aiDefaultLogStream -{ - /** Stream the log to a file */ - aiDefaultLogStream_FILE = 0x1, - - /** Stream the log to std::cout */ - aiDefaultLogStream_STDOUT = 0x2, - - /** Stream the log to std::cerr */ - aiDefaultLogStream_STDERR = 0x4, - - /** MSVC only: Stream the log the the debugger - * (this relies on OutputDebugString from the Win32 SDK) - */ - aiDefaultLogStream_DEBUGGER = 0x8, - - /** @cond never - * Force 32-bit size enum - */ - _AI_DLS_ENFORCE_ENUM_SIZE = 0x7fffffff -}; // !enum aiDefaultLogStream - -// just for backwards compatibility, don't use these constants anymore -#define DLS_FILE aiDefaultLogStream_FILE -#define DLS_STDOUT aiDefaultLogStream_STDOUT -#define DLS_STDERR aiDefaultLogStream_STDERR -#define DLS_DEBUGGER aiDefaultLogStream_DEBUGGER - -// ---------------------------------------------------------------------------------- -/** Stores the memory requirements for different components (e.g. meshes, materials, - * animations) of an import. All sizes are in bytes. - * @see Importer::GetMemoryRequirements() -*/ -struct aiMemoryInfo -{ -#ifdef __cplusplus - - /** Default constructor */ - aiMemoryInfo() - : textures (0) - , materials (0) - , meshes (0) - , nodes (0) - , animations (0) - , cameras (0) - , lights (0) - , total (0) - {} - -#endif - - /** Storage allocated for texture data */ - unsigned int textures; - - /** Storage allocated for material data */ - unsigned int materials; - - /** Storage allocated for mesh data */ - unsigned int meshes; - - /** Storage allocated for node data */ - unsigned int nodes; - - /** Storage allocated for animation data */ - unsigned int animations; - - /** Storage allocated for camera data */ - unsigned int cameras; - - /** Storage allocated for light data */ - unsigned int lights; - - /** Total storage allocated for the full import. */ - unsigned int total; -}; // !struct aiMemoryInfo - -#ifdef __cplusplus -} -#endif //! __cplusplus - -// Include implementations -#include "aiVector3D.inl" -#include "aiColor4D.inl" -#include "aiMatrix3x3.inl" -#include "aiMatrix4x4.inl" -#endif diff --git a/3rdparty/assimp/include/aiVector2D.h b/3rdparty/assimp/include/aiVector2D.h deleted file mode 100644 index c9533aa7..00000000 --- a/3rdparty/assimp/include/aiVector2D.h +++ /dev/null @@ -1,187 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ -/** @file aiVector2D.h - * @brief 2D vector structure, including operators when compiling in C++ - */ -#ifndef AI_VECTOR2D_H_INC -#define AI_VECTOR2D_H_INC - -#include <math.h> - -#ifdef __cplusplus -extern "C" { -#endif - -#include "./Compiler/pushpack1.h" - -// ---------------------------------------------------------------------------------- -/** Represents a two-dimensional vector. - */ -struct aiVector2D -{ -#ifdef __cplusplus - aiVector2D () : x(0.0f), y(0.0f) {} - aiVector2D (float _x, float _y) : x(_x), y(_y) {} - aiVector2D (float _xyz) : x(_xyz), y(_xyz) {} - aiVector2D (const aiVector2D& o) : x(o.x), y(o.y) {} - - void Set( float pX, float pY) { - x = pX; y = pY; - } - - float SquareLength() const { - return x*x + y*y; - } - - float Length() const { - return ::sqrt( SquareLength()); - } - - aiVector2D& Normalize() { - *this /= Length(); return *this; - } - - const aiVector2D& operator += (const aiVector2D& o) { - x += o.x; y += o.y; return *this; - } - const aiVector2D& operator -= (const aiVector2D& o) { - x -= o.x; y -= o.y; return *this; - } - const aiVector2D& operator *= (float f) { - x *= f; y *= f; return *this; - } - const aiVector2D& operator /= (float f) { - x /= f; y /= f; return *this; - } - - float operator[](unsigned int i) const { - return *(&x + i); - } - - float& operator[](unsigned int i) { - return *(&x + i); - } - - bool operator== (const aiVector2D& other) const { - return x == other.x && y == other.y; - } - - bool operator!= (const aiVector2D& other) const { - return x != other.x || y != other.y; - } - - aiVector2D& operator= (float f) { - x = y = f;return *this; - } - - const aiVector2D SymMul(const aiVector2D& o) { - return aiVector2D(x*o.x,y*o.y); - } - -#endif // __cplusplus - - float x, y; -} PACK_STRUCT; - -#include "./Compiler/poppack1.h" - -#ifdef __cplusplus -} // end extern "C" - -// ---------------------------------------------------------------------------------- -// symmetric addition -inline aiVector2D operator + (const aiVector2D& v1, const aiVector2D& v2) -{ - return aiVector2D( v1.x + v2.x, v1.y + v2.y); -} - -// ---------------------------------------------------------------------------------- -// symmetric subtraction -inline aiVector2D operator - (const aiVector2D& v1, const aiVector2D& v2) -{ - return aiVector2D( v1.x - v2.x, v1.y - v2.y); -} - -// ---------------------------------------------------------------------------------- -// scalar product -inline float operator * (const aiVector2D& v1, const aiVector2D& v2) -{ - return v1.x*v2.x + v1.y*v2.y; -} - -// ---------------------------------------------------------------------------------- -// scalar multiplication -inline aiVector2D operator * ( float f, const aiVector2D& v) -{ - return aiVector2D( f*v.x, f*v.y); -} - -// ---------------------------------------------------------------------------------- -// and the other way around -inline aiVector2D operator * ( const aiVector2D& v, float f) -{ - return aiVector2D( f*v.x, f*v.y); -} - -// ---------------------------------------------------------------------------------- -// scalar division -inline aiVector2D operator / ( const aiVector2D& v, float f) -{ - - return v * (1/f); -} - -// ---------------------------------------------------------------------------------- -// vector division -inline aiVector2D operator / ( const aiVector2D& v, const aiVector2D& v2) -{ - return aiVector2D(v.x / v2.x,v.y / v2.y); -} - -// ---------------------------------------------------------------------------------- -// vector inversion -inline aiVector2D operator - ( const aiVector2D& v) -{ - return aiVector2D( -v.x, -v.y); -} - -#endif // __cplusplus -#endif // AI_VECTOR2D_H_INC diff --git a/3rdparty/assimp/include/aiVector3D.h b/3rdparty/assimp/include/aiVector3D.h deleted file mode 100644 index 3a6a6ff3..00000000 --- a/3rdparty/assimp/include/aiVector3D.h +++ /dev/null @@ -1,129 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ -/** @file aiVector3D.h - * @brief 3D vector structure, including operators when compiling in C++ - */ -#ifndef AI_VECTOR3D_H_INC -#define AI_VECTOR3D_H_INC - -#include <math.h> - -#ifdef __cplusplus -extern "C" { -#endif - -#include "./Compiler/pushpack1.h" - -struct aiMatrix3x3; -struct aiMatrix4x4; - -// --------------------------------------------------------------------------- -/** Represents a three-dimensional vector. */ -struct aiVector3D -{ -#ifdef __cplusplus - aiVector3D () : x(0.0f), y(0.0f), z(0.0f) {} - aiVector3D (float _x, float _y, float _z) : x(_x), y(_y), z(_z) {} - aiVector3D (float _xyz) : x(_xyz), y(_xyz), z(_xyz) {} - aiVector3D (const aiVector3D& o) : x(o.x), y(o.y), z(o.z) {} - -public: - - // combined operators - const aiVector3D& operator += (const aiVector3D& o); - const aiVector3D& operator -= (const aiVector3D& o); - const aiVector3D& operator *= (float f); - const aiVector3D& operator /= (float f); - - // transform vector by matrix - aiVector3D& operator *= (const aiMatrix3x3& mat); - aiVector3D& operator *= (const aiMatrix4x4& mat); - - // access a single element - float operator[](unsigned int i) const; - float& operator[](unsigned int i); - - // comparison - bool operator== (const aiVector3D& other) const; - bool operator!= (const aiVector3D& other) const; - -public: - - /** @brief Set the components of a vector - * @param pX X component - * @param pY Y component - * @param pZ Z component */ - void Set( float pX, float pY, float pZ = 0.f); - - /** @brief Get the squared length of the vector - * @return Square length */ - float SquareLength() const; - - - /** @brief Get the length of the vector - * @return length */ - float Length() const; - - - /** @brief Normalize the vector */ - aiVector3D& Normalize(); - - - /** @brief Componentwise multiplication of two vectors - * - * Note that vec*vec yields the dot product. - * @param o Second factor */ - const aiVector3D SymMul(const aiVector3D& o); - -#endif // __cplusplus - - float x, y, z; -} PACK_STRUCT; - -#include "./Compiler/poppack1.h" - -#ifdef __cplusplus -} // end extern "C" - - -#endif // __cplusplus - -#endif // AI_VECTOR3D_H_INC diff --git a/3rdparty/assimp/include/aiVector3D.inl b/3rdparty/assimp/include/aiVector3D.inl deleted file mode 100644 index c14b347b..00000000 --- a/3rdparty/assimp/include/aiVector3D.inl +++ /dev/null @@ -1,180 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiVector3D.inl - * @brief Inline implementation of aiVector3D operators - */ -#ifndef AI_VECTOR3D_INL_INC -#define AI_VECTOR3D_INL_INC - -#include "aiVector3D.h" -#ifdef __cplusplus - -// ------------------------------------------------------------------------------------------------ -/** Transformation of a vector by a 3x3 matrix */ -inline aiVector3D operator * (const aiMatrix3x3& pMatrix, const aiVector3D& pVector) -{ - aiVector3D res; - 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.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z; - return res; -} - -// ------------------------------------------------------------------------------------------------ -/** Transformation of a vector by a 4x4 matrix */ -inline aiVector3D operator * (const aiMatrix4x4& pMatrix, const aiVector3D& pVector) -{ - aiVector3D res; - 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.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z + pMatrix.c4; - return res; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE void aiVector3D::Set( float pX, float pY, float pZ) { - x = pX; y = pY; z = pZ; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE float aiVector3D::SquareLength() const { - return x*x + y*y + z*z; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE float aiVector3D::Length() const { - return sqrt( SquareLength()); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE aiVector3D& aiVector3D::Normalize() { - *this /= Length(); return *this; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE const aiVector3D& aiVector3D::operator += (const aiVector3D& o) { - x += o.x; y += o.y; z += o.z; return *this; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE const aiVector3D& aiVector3D::operator -= (const aiVector3D& o) { - x -= o.x; y -= o.y; z -= o.z; return *this; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE const aiVector3D& aiVector3D::operator *= (float f) { - x *= f; y *= f; z *= f; return *this; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE const aiVector3D& aiVector3D::operator /= (float f) { - x /= f; y /= f; z /= f; return *this; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE aiVector3D& aiVector3D::operator *= (const aiMatrix3x3& mat){ - return(*this = mat * (*this)); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE aiVector3D& aiVector3D::operator *= (const aiMatrix4x4& mat){ - return(*this = mat * (*this)); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE float aiVector3D::operator[](unsigned int i) const { - return *(&x + i); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE float& aiVector3D::operator[](unsigned int i) { - return *(&x + i); -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE bool aiVector3D::operator== (const aiVector3D& other) const { - return x == other.x && y == other.y && z == other.z; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE bool aiVector3D::operator!= (const aiVector3D& other) const { - return x != other.x || y != other.y || z != other.z; -} -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE const aiVector3D aiVector3D::SymMul(const aiVector3D& o) { - return aiVector3D(x*o.x,y*o.y,z*o.z); -} -// ------------------------------------------------------------------------------------------------ -// symmetric addition -AI_FORCE_INLINE aiVector3D operator + (const aiVector3D& v1, const aiVector3D& v2) { - return aiVector3D( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z); -} -// ------------------------------------------------------------------------------------------------ -// symmetric subtraction -AI_FORCE_INLINE aiVector3D operator - (const aiVector3D& v1, const aiVector3D& v2) { - return aiVector3D( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z); -} -// ------------------------------------------------------------------------------------------------ -// scalar product -AI_FORCE_INLINE float operator * (const aiVector3D& v1, const aiVector3D& v2) { - return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z; -} -// ------------------------------------------------------------------------------------------------ -// scalar multiplication -AI_FORCE_INLINE aiVector3D operator * ( float f, const aiVector3D& v) { - return aiVector3D( f*v.x, f*v.y, f*v.z); -} -// ------------------------------------------------------------------------------------------------ -// and the other way around -AI_FORCE_INLINE aiVector3D operator * ( const aiVector3D& v, float f) { - return aiVector3D( f*v.x, f*v.y, f*v.z); -} -// ------------------------------------------------------------------------------------------------ -// scalar division -AI_FORCE_INLINE aiVector3D operator / ( const aiVector3D& v, float f) { - return v * (1/f); -} -// ------------------------------------------------------------------------------------------------ -// vector division -AI_FORCE_INLINE aiVector3D operator / ( const aiVector3D& v, const aiVector3D& v2) { - return aiVector3D(v.x / v2.x,v.y / v2.y,v.z / v2.z); -} -// ------------------------------------------------------------------------------------------------ -// cross product -AI_FORCE_INLINE aiVector3D operator ^ ( const aiVector3D& v1, const aiVector3D& v2) { - return aiVector3D( 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 inversion -AI_FORCE_INLINE aiVector3D operator - ( const aiVector3D& v) { - return aiVector3D( -v.x, -v.y, -v.z); -} - - -#endif // __cplusplus -#endif // AI_VECTOR3D_INL_INC diff --git a/3rdparty/assimp/include/aiVersion.h b/3rdparty/assimp/include/aiVersion.h deleted file mode 100644 index 98e95b7d..00000000 --- a/3rdparty/assimp/include/aiVersion.h +++ /dev/null @@ -1,104 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file aiVersion.h - * @brief Functions to query the version of the Assimp runtime, check - * compile flags, ... - */ -#ifndef INCLUDED_AI_VERSION_H -#define INCLUDED_AI_VERSION_H - -#ifdef __cplusplus -extern "C" { -#endif - -// --------------------------------------------------------------------------- -/** @brief Returns a string with legal copyright and licensing information - * about Assimp. The string may include multiple lines. - * @return Pointer to static string. - */ -ASSIMP_API const char* aiGetLegalString (void); - -// --------------------------------------------------------------------------- -/** @brief Returns the current minor version number of Assimp. - * @return Minor version of the Assimp runtime the application was - * linked/built against - */ -ASSIMP_API unsigned int aiGetVersionMinor (void); - -// --------------------------------------------------------------------------- -/** @brief Returns the current major version number of Assimp. - * @return Major version of the Assimp runtime the application was - * linked/built against - */ -ASSIMP_API unsigned int aiGetVersionMajor (void); - -// --------------------------------------------------------------------------- -/** @brief Returns the repository revision of the Assimp runtime. - * @return SVN Repository revision number of the Assimp runtime the - * application was linked/built against - */ -ASSIMP_API unsigned int aiGetVersionRevision (void); - - -//! Assimp was compiled as a shared object (Windows: DLL) -#define ASSIMP_CFLAGS_SHARED 0x1 -//! Assimp was compiled against STLport -#define ASSIMP_CFLAGS_STLPORT 0x2 -//! Assimp was compiled as a debug build -#define ASSIMP_CFLAGS_DEBUG 0x4 - -//! Assimp was compiled with ASSIMP_BUILD_BOOST_WORKAROUND defined -#define ASSIMP_CFLAGS_NOBOOST 0x8 -//! Assimp was compiled with ASSIMP_BUILD_SINGLETHREADED defined -#define ASSIMP_CFLAGS_SINGLETHREADED 0x10 - -// --------------------------------------------------------------------------- -/** @brief Returns assimp's compile flags - * @return Any bitwise combination of the ASSIMP_CFLAGS_xxx constants. - */ -ASSIMP_API unsigned int aiGetCompileFlags (void); - -#ifdef __cplusplus -} // end extern "C" -#endif - -#endif // !! #ifndef INCLUDED_AI_VERSION_H diff --git a/3rdparty/assimp/include/assimp.h b/3rdparty/assimp/include/assimp.h deleted file mode 100644 index bc1a6cdd..00000000 --- a/3rdparty/assimp/include/assimp.h +++ /dev/null @@ -1,434 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file assimp.h - * @brief Defines the C-API to the Open Asset Import Library. - */ -#ifndef AI_ASSIMP_H_INC -#define AI_ASSIMP_H_INC -#include "aiTypes.h" - -#ifdef __cplusplus -extern "C" { -#endif - -struct aiScene; // aiScene.h -struct aiFileIO; // aiFileIO.h -typedef void (*aiLogStreamCallback)(const char* /* message */, char* /* user */); - -// -------------------------------------------------------------------------------- -/** C-API: Represents a log stream. A log stream receives all log messages and - * streams them _somewhere_. - * @see aiGetPredefinedLogStream - * @see aiAttachLogStream - * @see aiDetachLogStream */ -// -------------------------------------------------------------------------------- -struct aiLogStream -{ - /** callback to be called */ - aiLogStreamCallback callback; - - /** user data to be passed to the callback */ - char* user; -}; - -/** Our own C boolean type */ -typedef int aiBool; - -#define AI_FALSE 0 -#define AI_TRUE 1 - -// -------------------------------------------------------------------------------- -/** Reads the given file and returns its content. - * - * If the call succeeds, the imported data is returned in an aiScene structure. - * The data is intended to be read-only, it stays property of the ASSIMP - * library and will be stable until aiReleaseImport() is called. After you're - * done with it, call aiReleaseImport() to free the resources associated with - * this file. If the import fails, NULL is returned instead. Call - * aiGetErrorString() to retrieve a human-readable error text. - * @param pFile Path and filename of the file to be imported, - * expected to be a null-terminated c-string. NULL is not a valid value. - * @param pFlags Optional post processing steps to be executed after - * a successful import. Provide a bitwise combination of the - * #aiPostProcessSteps flags. - * @return Pointer to the imported data or NULL if the import failed. - */ -ASSIMP_API const C_STRUCT aiScene* aiImportFile( - const char* pFile, - unsigned int pFlags); - -// -------------------------------------------------------------------------------- -/** Reads the given file using user-defined I/O functions and returns - * its content. - * - * If the call succeeds, the imported data is returned in an aiScene structure. - * The data is intended to be read-only, it stays property of the ASSIMP - * library and will be stable until aiReleaseImport() is called. After you're - * done with it, call aiReleaseImport() to free the resources associated with - * this file. If the import fails, NULL is returned instead. Call - * aiGetErrorString() to retrieve a human-readable error text. - * @param pFile Path and filename of the file to be imported, - * expected to be a null-terminated c-string. NULL is not a valid value. - * @param pFlags Optional post processing steps to be executed after - * a successful import. Provide a bitwise combination of the - * #aiPostProcessSteps flags. - * @param pFS aiFileIO structure. Will be used to open the model file itself - * and any other files the loader needs to open. - * @return Pointer to the imported data or NULL if the import failed. - * @note Include <aiFileIO.h> for the definition of #aiFileIO. - */ -ASSIMP_API const C_STRUCT aiScene* aiImportFileEx( - const char* pFile, - unsigned int pFlags, - C_STRUCT aiFileIO* pFS); - -// -------------------------------------------------------------------------------- -/** Reads the given file from a given memory buffer, - * - * If the call succeeds, the contents of the file are returned as a pointer to an - * aiScene object. The returned data is intended to be read-only, the importer keeps - * ownership of the data and will destroy it upon destruction. If the import fails, - * NULL is returned. - * A human-readable error description can be retrieved by calling aiGetErrorString(). - * @param pBuffer Pointer to the file data - * @param pLength Length of pBuffer, in bytes - * @param pFlags Optional post processing steps to be executed after - * a successful import. Provide a bitwise combination of the - * #aiPostProcessSteps flags. If you wish to inspect the imported - * scene first in order to fine-tune your post-processing setup, - * consider to use #aiApplyPostProcessing(). - * @param pHint An additional hint to the library. If this is a non empty string, - * the library looks for a loader to support the file extension specified by pHint - * and passes the file to the first matching loader. If this loader is unable to - * completely the request, the library continues and tries to determine the file - * format on its own, a task that may or may not be successful. - * Check the return value, and you'll know ... - * @return A pointer to the imported data, NULL if the import failed. - * - * @note This is a straightforward way to decode models from memory buffers, but it - * doesn't handle model formats spreading their data across multiple files or even - * directories. Examples include OBJ or MD3, which outsource parts of their material - * stuff into external scripts. If you need the full functionality, provide a custom - * IOSystem to make Assimp find these files. - */ -ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemory( - const char* pBuffer, - unsigned int pLength, - unsigned int pFlags, - const char* pHint); - -// -------------------------------------------------------------------------------- -/** Apply post-processing to an already-imported scene. - * - * This is strictly equivalent to calling #aiImportFile()/#aiImportFileEx with the - * same flags. However, you can use this separate function to inspect the imported - * scene first to fine-tune your post-processing setup. - * @param pScene Scene to work on. - * @param pFlags Provide a bitwise combination of the #aiPostProcessSteps flags. - * @return A pointer to the post-processed data. Post processing is done in-place, - * meaning this is still the same #aiScene which you passed for pScene. However, - * _if_ post-processing failed, the scene could now be NULL. That's quite a rare - * case, post processing steps are not really designed to 'fail'. To be exact, - * the #aiProcess_ValidateDS flag is currently the only post processing step - * which can actually cause the scene to be reset to NULL. - */ -ASSIMP_API const C_STRUCT aiScene* aiApplyPostProcessing( - const C_STRUCT aiScene* pScene, - unsigned int pFlags); - -// -------------------------------------------------------------------------------- -/** Get one of the predefine log streams. This is the quick'n'easy solution to - * access Assimp's log system. Attaching a log stream can slightly reduce Assimp's - * overall import performance. - * - * Usage is rather simple (this will stream the log to a file, named log.txt, and - * the stdout stream of the process: - * @code - * struct aiLogStream c; - * c = aiGetPredefinedLogStream(aiDefaultLogStream_FILE,"log.txt"); - * aiAttachLogStream(&c); - * c = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT,NULL); - * aiAttachLogStream(&c); - * @endcode - * - * @param pStreams One of the #aiDefaultLogStream enumerated values. - * @param file Solely for the #aiDefaultLogStream_FILE flag: specifies the file to write to. - * Pass NULL for all other flags. - * @return The log stream. callback is set to NULL if something went wrong. - */ -ASSIMP_API C_STRUCT aiLogStream aiGetPredefinedLogStream( - C_ENUM aiDefaultLogStream pStreams, - const char* file); - -// -------------------------------------------------------------------------------- -/** Attach a custom log stream to the libraries' logging system. - * - * Attaching a log stream can slightly reduce Assimp's overall import - * performance. Multiple log-streams can be attached. - * @param stream Describes the new log stream. - * @note To ensure proepr destruction of the logging system, you need to manually - * call aiDetachLogStream() on every single log stream you attach. - * Alternatively (for the lazy folks) #aiDetachAllLogStreams is provided. - */ -ASSIMP_API void aiAttachLogStream( - const C_STRUCT aiLogStream* stream); - -// -------------------------------------------------------------------------------- -/** Enable verbose logging. Verbose logging includes debug-related stuff and - * detailed import statistics. This can have severe impact on import performance - * and memory consumption. However, it might be useful to find out why a file - * didn't read correctly. - * @param d AI_TRUE or AI_FALSE, your decision. - */ -ASSIMP_API void aiEnableVerboseLogging(aiBool d); - -// -------------------------------------------------------------------------------- -/** Detach a custom log stream from the libraries' logging system. - * - * This is the counterpart of #aiAttachPredefinedLogStream. If you attached a stream, - * don't forget to detach it again. - * @param stream The log stream to be detached. - * @return AI_SUCCESS if the log stream has been detached successfully. - * @see aiDetachAllLogStreams - */ -ASSIMP_API C_ENUM aiReturn aiDetachLogStream( - const C_STRUCT aiLogStream* stream); - -// -------------------------------------------------------------------------------- -/** Detach all active log streams from the libraries' logging system. - * This ensures that the logging system is terminated properly and all - * resources allocated by it are actually freed. If you attached a stream, - * don't forget to detach it again. - * @see aiAttachLogStream - * @see aiDetachLogStream - */ -ASSIMP_API void aiDetachAllLogStreams(void); - -// -------------------------------------------------------------------------------- -/** Releases all resources associated with the given import process. - * - * Call this function after you're done with the imported data. - * @param pScene The imported data to release. NULL is a valid value. - */ -ASSIMP_API void aiReleaseImport( - const C_STRUCT aiScene* pScene); - -// -------------------------------------------------------------------------------- -/** Returns the error text of the last failed import process. - * - * @return A textual description of the error that occurred at the last - * import process. NULL if there was no error. There can't be an error if you - * got a non-NULL #aiScene from #aiImportFile/#aiImportFileEx/#aiApplyPostProcessing. - */ -ASSIMP_API const char* aiGetErrorString(); - -// -------------------------------------------------------------------------------- -/** Returns whether a given file extension is supported by ASSIMP - * - * @param szExtension Extension for which the function queries support for. - * Must include a leading dot '.'. Example: ".3ds", ".md3" - * @return AI_TRUE if the file extension is supported. - */ -ASSIMP_API aiBool aiIsExtensionSupported( - const char* szExtension); - -// -------------------------------------------------------------------------------- -/** Get a list of all file extensions supported by ASSIMP. - * - * If a file extension is contained in the list this does, of course, not - * mean that ASSIMP is able to load all files with this extension. - * @param szOut String to receive the extension list. - * Format of the list: "*.3ds;*.obj;*.dae". NULL is not a valid parameter. - */ -ASSIMP_API void aiGetExtensionList( - C_STRUCT aiString* szOut); - -// -------------------------------------------------------------------------------- -/** Get the storage required by an imported asset - * @param pIn Input asset. - * @param in Data structure to be filled. - */ -ASSIMP_API void aiGetMemoryRequirements( - const C_STRUCT aiScene* pIn, - C_STRUCT aiMemoryInfo* in); - -// -------------------------------------------------------------------------------- -/** Set an integer property. - * - * This is the C-version of #Assimp::Importer::SetPropertyInteger(). In the C - * interface, properties are always shared by all imports. It is not possible to - * specify them per import. - * - * @param szName Name of the configuration property to be set. All supported - * public properties are defined in the aiConfig.h header file (#AI_CONFIG_XXX). - * @param value New value for the property - */ -ASSIMP_API void aiSetImportPropertyInteger( - const char* szName, - int value); - -// -------------------------------------------------------------------------------- -/** Set a floating-point property. - * - * This is the C-version of #Assimp::Importer::SetPropertyFloat(). In the C - * interface, properties are always shared by all imports. It is not possible to - * specify them per import. - * - * @param szName Name of the configuration property to be set. All supported - * public properties are defined in the aiConfig.h header file (#AI_CONFIG_XXX). - * @param value New value for the property - */ -ASSIMP_API void aiSetImportPropertyFloat( - const char* szName, - float value); - -// -------------------------------------------------------------------------------- -/** Set a string property. - * - * This is the C-version of #Assimp::Importer::SetPropertyString(). In the C - * interface, properties are always shared by all imports. It is not possible to - * specify them per import. - * - * @param szName Name of the configuration property to be set. All supported - * public properties are defined in the aiConfig.h header file (#AI_CONFIG_XXX). - * @param value New value for the property - */ -ASSIMP_API void aiSetImportPropertyString( - const char* szName, - const C_STRUCT aiString* st); - -// -------------------------------------------------------------------------------- -/** Construct a quaternion from a 3x3 rotation matrix. - * @param quat Receives the output quaternion. - * @param mat Matrix to 'quaternionize'. - * @see aiQuaternion(const aiMatrix3x3& pRotMatrix) - */ -ASSIMP_API void aiCreateQuaternionFromMatrix( - C_STRUCT aiQuaternion* quat, - const C_STRUCT aiMatrix3x3* mat); - -// -------------------------------------------------------------------------------- -/** Decompose a transformation matrix into its rotational, translational and - * scaling components. - * - * @param mat Matrix to decompose - * @param scaling Receives the scaling component - * @param rotation Receives the rotational component - * @param position Receives the translational component. - * @see aiMatrix4x4::Decompose (aiVector3D&, aiQuaternion&, aiVector3D&) const; - */ -ASSIMP_API void aiDecomposeMatrix( - const C_STRUCT aiMatrix4x4* mat, - C_STRUCT aiVector3D* scaling, - C_STRUCT aiQuaternion* rotation, - C_STRUCT aiVector3D* position); - -// -------------------------------------------------------------------------------- -/** Transpose a 4x4 matrix. - * @param mat Pointer to the matrix to be transposed - */ -ASSIMP_API void aiTransposeMatrix4( - C_STRUCT aiMatrix4x4* mat); - -// -------------------------------------------------------------------------------- -/** Transpose a 3x3 matrix. - * @param mat Pointer to the matrix to be transposed - */ -ASSIMP_API void aiTransposeMatrix3( - C_STRUCT aiMatrix3x3* mat); - -// -------------------------------------------------------------------------------- -/** Transform a vector by a 3x3 matrix - * @param vec Vector to be transformed. - * @param mat Matrix to transform the vector with. - */ -ASSIMP_API void aiTransformVecByMatrix3( - C_STRUCT aiVector3D* vec, - const C_STRUCT aiMatrix3x3* mat); - -// -------------------------------------------------------------------------------- -/** Transform a vector by a 4x4 matrix - * @param vec Vector to be transformed. - * @param mat Matrix to transform the vector with. - */ -ASSIMP_API void aiTransformVecByMatrix4( - C_STRUCT aiVector3D* vec, - const C_STRUCT aiMatrix4x4* mat); - -// -------------------------------------------------------------------------------- -/** Multiply two 4x4 matrices. - * @param dst First factor, receives result. - * @param src Matrix to be multiplied with 'dst'. - */ -ASSIMP_API void aiMultiplyMatrix4( - C_STRUCT aiMatrix4x4* dst, - const C_STRUCT aiMatrix4x4* src); - -// -------------------------------------------------------------------------------- -/** Multiply two 3x3 matrices. - * @param dst First factor, receives result. - * @param src Matrix to be multiplied with 'dst'. - */ -ASSIMP_API void aiMultiplyMatrix3( - C_STRUCT aiMatrix3x3* dst, - const C_STRUCT aiMatrix3x3* src); - -// -------------------------------------------------------------------------------- -/** Get a 3x3 identity matrix. - * @param mat Matrix to receive its personal identity - */ -ASSIMP_API void aiIdentityMatrix3( - C_STRUCT aiMatrix3x3* mat); - -// -------------------------------------------------------------------------------- -/** Get a 4x4 identity matrix. - * @param mat Matrix to receive its personal identity - */ -ASSIMP_API void aiIdentityMatrix4( - C_STRUCT aiMatrix4x4* mat); - - -#ifdef __cplusplus -} -#endif - -#endif // AI_ASSIMP_H_INC diff --git a/3rdparty/assimp/include/assimp.hpp b/3rdparty/assimp/include/assimp.hpp deleted file mode 100644 index 098a6cce..00000000 --- a/3rdparty/assimp/include/assimp.hpp +++ /dev/null @@ -1,609 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (ASSIMP) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2010, ASSIMP Development Team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the ASSIMP team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the ASSIMP Development Team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file assimp.hpp - * @brief Defines the C++-API to the Open Asset Import Library. - */ -#ifndef INCLUDED_AI_ASSIMP_HPP -#define INCLUDED_AI_ASSIMP_HPP - -#ifndef __cplusplus -# error This header requires C++ to be used. Use assimp.h for plain C. -#endif - -// Public ASSIMP data structures -#include "aiTypes.h" -#include "aiConfig.h" -#include "aiAssert.h" - -namespace Assimp { - // ======================================================================= - // Public interface to Assimp - class Importer; - class IOStream; - class IOSystem; - class ProgressHandler; - - // ======================================================================= - // Plugin development - // - // Include the following headers for the declarations: - // BaseImporter.h - // BaseProcess.h - class BaseImporter; - class BaseProcess; - class SharedPostProcessInfo; - class BatchLoader; - - // ======================================================================= - // Holy stuff, only for members of the high council of the Jedi. - class ImporterPimpl; -} //! namespace Assimp - -#define AI_PROPERTY_WAS_NOT_EXISTING 0xffffffff - -struct aiScene; -struct aiFileIO; -extern "C" ASSIMP_API const aiScene* aiImportFileEx( const char*, unsigned int, aiFileIO*); -extern "C" ASSIMP_API const aiScene* aiImportFileFromMemory( const char*, - unsigned int,unsigned int,const char*); - -/** @namespace Assimp Assimp's CPP-API and all internal APIs */ -namespace Assimp { - -// ---------------------------------------------------------------------------------- -/** CPP-API: The Importer class forms an C++ interface to the functionality of the -* Open Asset Import Library. -* -* Create an object of this class and call ReadFile() to import a file. -* If the import succeeds, the function returns a pointer to the imported data. -* The data remains property of the object, it is intended to be accessed -* read-only. The imported data will be destroyed along with the Importer -* object. If the import fails, ReadFile() returns a NULL pointer. In this -* case you can retrieve a human-readable error description be calling -* GetErrorString(). You can call ReadFile() multiple times with a single Importer -* instance. Actually, constructing Importer objects involves quite many -* allocations and may take some time, so it's better to reuse them as often as -* possible. -* -* If you need the Importer to do custom file handling to access the files, -* implement IOSystem and IOStream and supply an instance of your custom -* IOSystem implementation by calling SetIOHandler() before calling ReadFile(). -* If you do not assign a custion IO handler, a default handler using the -* standard C++ IO logic will be used. -* -* @note One Importer instance is not thread-safe. If you use multiple -* threads for loading, each thread should maintain its own Importer instance. -*/ -class ASSIMP_API Importer { - - // for internal use - friend class BaseProcess; - friend class BatchLoader; - friend const aiScene* ::aiImportFileEx( const char*, unsigned int, aiFileIO*); - friend const aiScene* ::aiImportFileFromMemory( const char*, - unsigned int,unsigned int,const char*); - -public: - - // ------------------------------------------------------------------- - /** Constructor. Creates an empty importer object. - * - * Call ReadFile() to start the import process. The configuration - * property table is initially empty. - */ - Importer(); - - // ------------------------------------------------------------------- - /** Copy constructor. - * - * This copies the configuration properties of another Importer. - * If this Importer owns a scene it won't be copied. - * Call ReadFile() to start the import process. - */ - Importer(const Importer& other); - - // ------------------------------------------------------------------- - /** Destructor. The object kept ownership of the imported data, - * which now will be destroyed along with the object. - */ - ~Importer(); - - - // ------------------------------------------------------------------- - /** Registers a new loader. - * - * @param pImp Importer to be added. The Importer instance takes - * ownership of the pointer, so it will be automatically deleted - * with the Importer instance. - * @return AI_SUCCESS if the loader has been added. The registration - * fails if there is already a loader for a specific file extension. - */ - aiReturn RegisterLoader(BaseImporter* pImp); - - // ------------------------------------------------------------------- - /** Unregisters a loader. - * - * @param pImp Importer to be unregistered. - * @return AI_SUCCESS if the loader has been removed. The function - * fails if the loader is currently in use (this could happen - * if the #Importer instance is used by more than one thread) or - * if it has not yet been registered. - */ - aiReturn UnregisterLoader(BaseImporter* pImp); - - // ------------------------------------------------------------------- - /** Registers a new post-process step. - * - * At the moment, there's a small limitation: new post processing - * steps are added to end of the list, or in other words, executed - * last, after all built-in steps. - * @param pImp Post-process step to be added. The Importer instance - * takes ownership of the pointer, so it will be automatically - * deleted with the Importer instance. - * @return AI_SUCCESS if the step has been added correctly. - */ - aiReturn RegisterPPStep(BaseProcess* pImp); - - // ------------------------------------------------------------------- - /** Unregisters a post-process step. - * - * @param pImp Step to be unregistered. - * @return AI_SUCCESS if the step has been removed. The function - * fails if the step is currently in use (this could happen - * if the #Importer instance is used by more than one thread) or - * if it has not yet been registered. - */ - aiReturn UnregisterPPStep(BaseProcess* pImp); - - - // ------------------------------------------------------------------- - /** Set an integer configuration property. - * @param szName Name of the property. All supported properties - * are defined in the aiConfig.g header (all constants share the - * prefix AI_CONFIG_XXX and are simple strings). - * @param iValue New value of the property - * @param bWasExisting Optional pointer to receive true if the - * property was set before. The new value replaces the previous value - * in this case. - * @note Property of different types (float, int, string ..) are kept - * on different stacks, so calling SetPropertyInteger() for a - * floating-point property has no effect - the loader will call - * GetPropertyFloat() to read the property, but it won't be there. - */ - void SetPropertyInteger(const char* szName, int iValue, - bool* bWasExisting = NULL); - - // ------------------------------------------------------------------- - /** Set a boolean configuration property. Boolean properties - * are stored on the integer stack internally so it's possible - * to set them via #SetPropertyBool and query them with - * #GetPropertyBool and vice versa. - * @see SetPropertyInteger() - */ - void SetPropertyBool(const char* szName, bool value, bool* bWasExisting = NULL) { - SetPropertyInteger(szName,value); - } - - // ------------------------------------------------------------------- - /** Set a floating-point configuration property. - * @see SetPropertyInteger() - */ - void SetPropertyFloat(const char* szName, float fValue, - bool* bWasExisting = NULL); - - // ------------------------------------------------------------------- - /** Set a string configuration property. - * @see SetPropertyInteger() - */ - void SetPropertyString(const char* szName, const std::string& sValue, - bool* bWasExisting = NULL); - - // ------------------------------------------------------------------- - /** Get a configuration property. - * @param szName Name of the property. All supported properties - * are defined in the aiConfig.g header (all constants share the - * prefix AI_CONFIG_XXX). - * @param iErrorReturn Value that is returned if the property - * is not found. - * @return Current value of the property - * @note Property of different types (float, int, string ..) are kept - * on different lists, so calling SetPropertyInteger() for a - * floating-point property has no effect - the loader will call - * GetPropertyFloat() to read the property, but it won't be there. - */ - int GetPropertyInteger(const char* szName, - int iErrorReturn = 0xffffffff) const; - - // ------------------------------------------------------------------- - /** Get a boolean configuration property. Boolean properties - * are stored on the integer stack internally so it's possible - * to set them via #SetPropertyBool and query them with - * #GetPropertyBool and vice versa. - * @see GetPropertyInteger() - */ - bool GetPropertyBool(const char* szName, bool bErrorReturn = false) const { - return GetPropertyInteger(szName,bErrorReturn)!=0; - } - - // ------------------------------------------------------------------- - /** Get a floating-point configuration property - * @see GetPropertyInteger() - */ - float GetPropertyFloat(const char* szName, - float fErrorReturn = 10e10f) const; - - // ------------------------------------------------------------------- - /** Get a string configuration property - * - * The return value remains valid until the property is modified. - * @see GetPropertyInteger() - */ - const std::string& GetPropertyString(const char* szName, - const std::string& sErrorReturn = "") const; - - // ------------------------------------------------------------------- - /** Supplies a custom IO handler to the importer to use to open and - * access files. If you need the importer to use custion IO logic to - * access the files, you need to provide a custom implementation of - * IOSystem and IOFile to the importer. Then create an instance of - * your custion IOSystem implementation and supply it by this function. - * - * The Importer takes ownership of the object and will destroy it - * afterwards. The previously assigned handler will be deleted. - * Pass NULL to take again ownership of your IOSystem and reset Assimp - * to use its default implementation. - * - * @param pIOHandler The IO handler to be used in all file accesses - * of the Importer. - */ - void SetIOHandler( IOSystem* pIOHandler); - - // ------------------------------------------------------------------- - /** Retrieves the IO handler that is currently set. - * You can use #IsDefaultIOHandler() to check whether the returned - * interface is the default IO handler provided by ASSIMP. The default - * handler is active as long the application doesn't supply its own - * custom IO handler via #SetIOHandler(). - * @return A valid IOSystem interface, never NULL. - */ - IOSystem* GetIOHandler() const; - - // ------------------------------------------------------------------- - /** Checks whether a default IO handler is active - * A default handler is active as long the application doesn't - * supply its own custom IO handler via #SetIOHandler(). - * @return true by default - */ - bool IsDefaultIOHandler() const; - - // ------------------------------------------------------------------- - /** Supplies a custom progress handler to the importer. This - * interface exposes a #Update() callback, which is called - * more or less periodically (please don't sue us if it - * isn't as periodically as you'd like it to have ...). - * This can be used to implement progress bars and loading - * timeouts. - * @param pHandler Progress callback interface. Pass NULL to - * disable progress reporting. - * @note Progress handlers can be used to abort the loading - * at almost any time.*/ - void SetProgressHandler ( ProgressHandler* pHandler ); - - // ------------------------------------------------------------------- - /** Retrieves the progress handler that is currently set. - * You can use #IsDefaultProgressHandler() to check whether the returned - * interface is the default handler provided by ASSIMP. The default - * handler is active as long the application doesn't supply its own - * custom handler via #SetProgressHandler(). - * @return A valid ProgressHandler interface, never NULL. - */ - ProgressHandler* GetProgressHandler() const; - - // ------------------------------------------------------------------- - /** Checks whether a default progress handler is active - * A default handler is active as long the application doesn't - * supply its own custom progress handler via #SetProgressHandler(). - * @return true by default - */ - bool IsDefaultProgressHandler() const; - - // ------------------------------------------------------------------- - /** @brief Check whether a given set of postprocessing flags - * is supported. - * - * Some flags are mutually exclusive, others are probably - * not available because your excluded them from your - * Assimp builds. Calling this function is recommended if - * you're unsure. - * - * @param pFlags Bitwise combination of the aiPostProcess flags. - * @return true if this flag combination is fine. - */ - bool ValidateFlags(unsigned int pFlags) const; - - // ------------------------------------------------------------------- - /** Reads the given file and returns its contents if successful. - * - * If the call succeeds, the contents of the file are returned as a - * pointer to an aiScene object. The returned data is intended to be - * read-only, the importer object keeps ownership of the data and will - * destroy it upon destruction. If the import fails, NULL is returned. - * A human-readable error description can be retrieved by calling - * GetErrorString(). The previous scene will be deleted during this call. - * @param pFile Path and filename to the file to be imported. - * @param pFlags Optional post processing steps to be executed after - * a successful import. Provide a bitwise combination of the - * #aiPostProcessSteps flags. If you wish to inspect the imported - * scene first in order to fine-tune your post-processing setup, - * consider to use #ApplyPostProcessing(). - * @return A pointer to the imported data, NULL if the import failed. - * The pointer to the scene remains in possession of the Importer - * instance. Use GetOrphanedScene() to take ownership of it. - * - * @note Assimp is able to determine the file format of a file - * automatically. - */ - const aiScene* ReadFile( - const char* pFile, - unsigned int pFlags); - - // ------------------------------------------------------------------- - /** Reads the given file from a memory buffer and returns its - * contents if successful. - * - * If the call succeeds, the contents of the file are returned as a - * pointer to an aiScene object. The returned data is intended to be - * read-only, the importer object keeps ownership of the data and will - * destroy it upon destruction. If the import fails, NULL is returned. - * A human-readable error description can be retrieved by calling - * GetErrorString(). The previous scene will be deleted during this call. - * Calling this method doesn't affect the active IOSystem. - * @param pBuffer Pointer to the file data - * @param pLength Length of pBuffer, in bytes - * @param pFlags Optional post processing steps to be executed after - * a successful import. Provide a bitwise combination of the - * #aiPostProcessSteps flags. If you wish to inspect the imported - * scene first in order to fine-tune your post-processing setup, - * consider to use #ApplyPostProcessing(). - * @param pHint An additional hint to the library. If this is a non - * empty string, the library looks for a loader to support - * the file extension specified by pHint and passes the file to - * the first matching loader. If this loader is unable to completely - * the request, the library continues and tries to determine the - * file format on its own, a task that may or may not be successful. - * Check the return value, and you'll know ... - * @return A pointer to the imported data, NULL if the import failed. - * The pointer to the scene remains in possession of the Importer - * instance. Use GetOrphanedScene() to take ownership of it. - * - * @note This is a straightforward way to decode models from memory - * buffers, but it doesn't handle model formats spreading their - * data across multiple files or even directories. Examples include - * OBJ or MD3, which outsource parts of their material stuff into - * external scripts. If you need the full functionality, provide - * a custom IOSystem to make Assimp find these files. - */ - const aiScene* ReadFileFromMemory( - const void* pBuffer, - size_t pLength, - unsigned int pFlags, - const char* pHint = ""); - - // ------------------------------------------------------------------- - /** Apply post-processing to an already-imported scene. - * - * This is strictly equivalent to calling #ReadFile() with the same - * flags. However, you can use this separate function to inspect - * the imported scene first to fine-tune your post-processing setup. - * @param pFlags Provide a bitwise combination of the - * #aiPostProcessSteps flags. - * @return A pointer to the post-processed data. This is still the - * same as the pointer returned by #ReadFile(). However, if - * post-processing fails, the scene could now be NULL. - * That's quite a rare case, post processing steps are not really - * designed to 'fail'. To be exact, the #aiProcess_ValidateDS - * flag is currently the only post processing step which can actually - * cause the scene to be reset to NULL. - * - * @note The method does nothing if no scene is currently bound - * to the #Importer instance. */ - const aiScene* ApplyPostProcessing(unsigned int pFlags); - - // ------------------------------------------------------------------- - /** @brief Reads the given file and returns its contents if successful. - * - * This function is provided for backward compatibility. - * See the const char* version for detailled docs. - * @see ReadFile(const char*, pFlags) */ - const aiScene* ReadFile( - const std::string& pFile, - unsigned int pFlags); - - // ------------------------------------------------------------------- - /** Frees the current scene. - * - * The function does nothing if no scene has previously been - * read via ReadFile(). FreeScene() is called automatically by the - * destructor and ReadFile() itself. */ - void FreeScene( ); - - // ------------------------------------------------------------------- - /** Returns an error description of an error that occurred in ReadFile(). - * - * Returns an empty string if no error occurred. - * @return A description of the last error, an empty string if no - * error occurred. The string is never NULL. - * - * @note The returned function remains valid until one of the - * following methods is called: #ReadFile(), #FreeScene(). */ - const char* GetErrorString() const; - - - // ------------------------------------------------------------------- - /** Returns whether a given file extension is supported by ASSIMP. - * - * @param szExtension Extension to be checked. - * Must include a trailing dot '.'. Example: ".3ds", ".md3". - * Cases-insensitive. - * @return true if the extension is supported, false otherwise */ - bool IsExtensionSupported(const char* szExtension) const; - - // ------------------------------------------------------------------- - /** @brief Returns whether a given file extension is supported by ASSIMP. - * - * This function is provided for backward compatibility. - * See the const char* version for detailed and up-to-date docs. - * @see IsExtensionSupported(const char*) */ - inline bool IsExtensionSupported(const std::string& szExtension) const; - - - // ------------------------------------------------------------------- - /** Get a full list of all file extensions supported by ASSIMP. - * - * If a file extension is contained in the list this does of course not - * mean that ASSIMP is able to load all files with this extension --- - * it simply means there is an importer loaded which claims to handle - * files with this file extension. - * @param szOut String to receive the extension list. - * Format of the list: "*.3ds;*.obj;*.dae". This is useful for - * use with the WinAPI call GetOpenFileName(Ex). */ - void GetExtensionList(aiString& szOut) const; - - // ------------------------------------------------------------------- - /** @brief Get a full list of all file extensions supported by ASSIMP. - * - * This function is provided for backward compatibility. - * See the aiString version for detailed and up-to-date docs. - * @see GetExtensionList(aiString&)*/ - inline void GetExtensionList(std::string& szOut) const; - - - // ------------------------------------------------------------------- - /** Find the loader corresponding to a specific file extension. - * - * This is quite similar to IsExtensionSupported() except a - * BaseImporter instance is returned. - * @param szExtension Extension to check for. The following formats - * are recgnized (BAH being the file extension): "BAH" (comparison - * is case-insensitive), ".bah", "*.bah" (wild card and dot - * characters at the beginning of the extension are skipped). - * @return NULL if there is no loader for the extension.*/ - BaseImporter* FindLoader (const char* szExtension) const; - - - // ------------------------------------------------------------------- - /** Returns the scene loaded by the last successful call to ReadFile() - * - * @return Current scene or NULL if there is currently no scene loaded */ - const aiScene* GetScene() const; - - // ------------------------------------------------------------------- - /** Returns the scene loaded by the last successful call to ReadFile() - * and releases the scene from the ownership of the Importer - * instance. The application is now responsible for deleting the - * scene. Any further calls to GetScene() or GetOrphanedScene() - * will return NULL - until a new scene has been loaded via ReadFile(). - * - * @return Current scene or NULL if there is currently no scene loaded - * @note Use this method with maximal caution, and only if you have to. - * By design, aiScene's are exclusively maintained, allocated and - * deallocated by Assimp and no one else. The reasoning behind this - * is the golden rule that deallocations should always be done - * by the module that did the original allocation because heaps - * are not necessarily shared. GetOrphanedScene() enforces you - * to delete the returned scene by yourself, but this will only - * be fine if and only if you're using the same heap as assimp. - * On Windows, it's typically fine when everything is linked - * against the multithreaded-dll version of the runtime library. - * It will work as well for static linkage with Assimp.*/ - aiScene* GetOrphanedScene(); - - // ------------------------------------------------------------------- - /** Returns the storage allocated by ASSIMP to hold the scene data - * in memory. - * - * This refers to the currently loaded file, see #ReadFile(). - * @param in Data structure to be filled. - * @note The returned memory statistics refer to the actual - * size of the use data of the aiScene. Heap-related overhead - * is (naturally) not included.*/ - void GetMemoryRequirements(aiMemoryInfo& in) const; - - // ------------------------------------------------------------------- - /** Enables "extra verbose" mode. - * - * 'Extra verbose' means the data structure is validated after *every* - * single post processing step to make sure everyone modifies the data - * structure in a well-defined manner. This is a debug feature and not - * intended for use in production environments. */ - void SetExtraVerbose(bool bDo); - -protected: - - // Just because we don't want you to know how we're hacking around. - ImporterPimpl* pimpl; -}; //! class Importer - - -// ---------------------------------------------------------------------------- -// For compatibility, the interface of some functions taking a std::string was -// changed to const char* to avoid crashes between binary incompatible STL -// versions. This code her is inlined, so it shouldn't cause any problems. -// ---------------------------------------------------------------------------- - -// ---------------------------------------------------------------------------- -AI_FORCE_INLINE const aiScene* Importer::ReadFile( const std::string& pFile,unsigned int pFlags){ - return ReadFile(pFile.c_str(),pFlags); -} -// ---------------------------------------------------------------------------- -AI_FORCE_INLINE void Importer::GetExtensionList(std::string& szOut) const { - aiString s; - GetExtensionList(s); - szOut = s.data; -} -// ---------------------------------------------------------------------------- -AI_FORCE_INLINE bool Importer::IsExtensionSupported(const std::string& szExtension) const { - return IsExtensionSupported(szExtension.c_str()); -} - -} // !namespace Assimp -#endif // INCLUDED_AI_ASSIMP_HPP |