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

Refactor: Expand tabs to 4 spaces

pull/566/head
Richard 2015-05-18 22:18:29 -06:00
parent 6da45599c0
commit 54a2d0808c
39 changed files with 5577 additions and 5577 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

172
include/assimp/DefaultLogger.hpp
View File

@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "NullLogger.hpp" #include "NullLogger.hpp"
#include <vector> #include <vector>
namespace Assimp { namespace Assimp {
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
class IOStream; class IOStream;
struct LogStreamInfo; struct LogStreamInfo;
@ -70,118 +70,118 @@ struct LogStreamInfo;
* implementation of #Logger to #set(). * implementation of #Logger to #set().
* @note The whole logging stuff causes a small extra overhead for all imports. */ * @note The whole logging stuff causes a small extra overhead for all imports. */
class ASSIMP_API DefaultLogger : class ASSIMP_API DefaultLogger :
public Logger { public Logger {
public: public:
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Creates a logging instance. /** @brief Creates a logging instance.
* @param name Name for log file. Only valid in combination * @param name Name for log file. Only valid in combination
* with the aiDefaultLogStream_FILE flag. * with the aiDefaultLogStream_FILE flag.
* @param severity Log severity, VERBOSE turns on debug messages * @param severity Log severity, VERBOSE turns on debug messages
* @param defStreams Default log streams to be attached. Any bitwise * @param defStreams Default log streams to be attached. Any bitwise
* combination of the aiDefaultLogStream enumerated values. * combination of the aiDefaultLogStream enumerated values.
* If #aiDefaultLogStream_FILE is specified but an empty string is * If #aiDefaultLogStream_FILE is specified but an empty string is
* passed for 'name', no log file is created at all. * passed for 'name', no log file is created at all.
* @param io IOSystem to be used to open external files (such as the * @param io IOSystem to be used to open external files (such as the
* log file). Pass NULL to rely on the default implementation. * log file). Pass NULL to rely on the default implementation.
* This replaces the default #NullLogger with a #DefaultLogger instance. */ * This replaces the default #NullLogger with a #DefaultLogger instance. */
static Logger *create(const char* name = ASSIMP_DEFAULT_LOG_NAME, static Logger *create(const char* name = ASSIMP_DEFAULT_LOG_NAME,
LogSeverity severity = NORMAL, LogSeverity severity = NORMAL,
unsigned int defStreams = aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE, unsigned int defStreams = aiDefaultLogStream_DEBUGGER | aiDefaultLogStream_FILE,
IOSystem* io = NULL); IOSystem* io = NULL);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Setup a custom #Logger implementation. /** @brief Setup a custom #Logger implementation.
* *
* Use this if the provided #DefaultLogger class doesn't fit into * Use this if the provided #DefaultLogger class doesn't fit into
* your needs. If the provided message formatting is OK for you, * your needs. If the provided message formatting is OK for you,
* it's much easier to use #create() and to attach your own custom * it's much easier to use #create() and to attach your own custom
* output streams to it. * output streams to it.
* @param logger Pass NULL to setup a default NullLogger*/ * @param logger Pass NULL to setup a default NullLogger*/
static void set (Logger *logger); static void set (Logger *logger);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Getter for singleton instance /** @brief Getter for singleton instance
* @return Only instance. This is never null, but it could be a * @return Only instance. This is never null, but it could be a
* NullLogger. Use isNullLogger to check this.*/ * NullLogger. Use isNullLogger to check this.*/
static Logger *get(); static Logger *get();
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Return whether a #NullLogger is currently active /** @brief Return whether a #NullLogger is currently active
* @return true if the current logger is a #NullLogger. * @return true if the current logger is a #NullLogger.
* Use create() or set() to setup a logger that does actually do * Use create() or set() to setup a logger that does actually do
* something else than just rejecting all log messages. */ * something else than just rejecting all log messages. */
static bool isNullLogger(); static bool isNullLogger();
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Kills the current singleton logger and replaces it with a /** @brief Kills the current singleton logger and replaces it with a
* #NullLogger instance. */ * #NullLogger instance. */
static void kill(); static void kill();
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @copydoc Logger::attachStream */ /** @copydoc Logger::attachStream */
bool attachStream(LogStream *pStream, bool attachStream(LogStream *pStream,
unsigned int severity); unsigned int severity);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @copydoc Logger::detatchStream */ /** @copydoc Logger::detatchStream */
bool detatchStream(LogStream *pStream, bool detatchStream(LogStream *pStream,
unsigned int severity); unsigned int severity);
private: private:
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @briefPrivate construction for internal use by create(). /** @briefPrivate construction for internal use by create().
* @param severity Logging granularity */ * @param severity Logging granularity */
DefaultLogger(LogSeverity severity); DefaultLogger(LogSeverity severity);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @briefDestructor */ /** @briefDestructor */
~DefaultLogger(); ~DefaultLogger();
private: private:
/** @brief Logs debug infos, only been written when severity level VERBOSE is set */ /** @brief Logs debug infos, only been written when severity level VERBOSE is set */
void OnDebug(const char* message); void OnDebug(const char* message);
/** @brief Logs an info message */ /** @brief Logs an info message */
void OnInfo(const char* message); void OnInfo(const char* message);
/** @brief Logs a warning message */ /** @brief Logs a warning message */
void OnWarn(const char* message); void OnWarn(const char* message);
/** @brief Logs an error message */ /** @brief Logs an error message */
void OnError(const char* message); void OnError(const char* message);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Writes a message to all streams */ /** @brief Writes a message to all streams */
void WriteToStreams(const char* message, ErrorSeverity ErrorSev ); void WriteToStreams(const char* message, ErrorSeverity ErrorSev );
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Returns the thread id. /** @brief Returns the thread id.
* @note This is an OS specific feature, if not supported, a * @note This is an OS specific feature, if not supported, a
* zero will be returned. * zero will be returned.
*/ */
unsigned int GetThreadID(); unsigned int GetThreadID();
private: private:
// Aliases for stream container // Aliases for stream container
typedef std::vector<LogStreamInfo*> StreamArray; typedef std::vector<LogStreamInfo*> StreamArray;
typedef std::vector<LogStreamInfo*>::iterator StreamIt; typedef std::vector<LogStreamInfo*>::iterator StreamIt;
typedef std::vector<LogStreamInfo*>::const_iterator ConstStreamIt; typedef std::vector<LogStreamInfo*>::const_iterator ConstStreamIt;
//! only logging instance //! only logging instance
static Logger *m_pLogger; static Logger *m_pLogger;
static NullLogger s_pNullLogger; static NullLogger s_pNullLogger;
//! Attached streams //! Attached streams
StreamArray m_StreamArray; StreamArray m_StreamArray;
bool noRepeatMsg; bool noRepeatMsg;
char lastMsg[MAX_LOG_MESSAGE_LENGTH*2]; char lastMsg[MAX_LOG_MESSAGE_LENGTH*2];
size_t lastLen; size_t lastLen;
}; };
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------

658
include/assimp/Exporter.hpp
View File

@ -50,9 +50,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "cexport.h" #include "cexport.h"
#include <map> #include <map>
namespace Assimp { namespace Assimp {
class ExporterPimpl; class ExporterPimpl;
class IOSystem; class IOSystem;
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
@ -77,426 +77,426 @@ namespace Assimp {
class ASSIMP_API ExportProperties; class ASSIMP_API ExportProperties;
class ASSIMP_API Exporter class ASSIMP_API Exporter
// TODO: causes good ol' base class has no dll interface warning // TODO: causes good ol' base class has no dll interface warning
//#ifdef __cplusplus //#ifdef __cplusplus
// : public boost::noncopyable // : public boost::noncopyable
//#endif // __cplusplus //#endif // __cplusplus
{ {
public: public:
/** Function pointer type of a Export worker function */ /** Function pointer type of a Export worker function */
typedef void (*fpExportFunc)(const char*, IOSystem*, const aiScene*, const ExportProperties*); typedef void (*fpExportFunc)(const char*, IOSystem*, const aiScene*, const ExportProperties*);
/** Internal description of an Assimp export format option */ /** Internal description of an Assimp export format option */
struct ExportFormatEntry struct ExportFormatEntry
{ {
/// Public description structure to be returned by aiGetExportFormatDescription() /// Public description structure to be returned by aiGetExportFormatDescription()
aiExportFormatDesc mDescription; aiExportFormatDesc mDescription;
// Worker function to do the actual exporting // Worker function to do the actual exporting
fpExportFunc mExportFunction; fpExportFunc mExportFunction;
// Postprocessing steps to be executed PRIOR to invoking mExportFunction // Postprocessing steps to be executed PRIOR to invoking mExportFunction
unsigned int mEnforcePP; unsigned int mEnforcePP;
// Constructor to fill all entries // Constructor to fill all entries
ExportFormatEntry( const char* pId, const char* pDesc, const char* pExtension, fpExportFunc pFunction, unsigned int pEnforcePP = 0u) ExportFormatEntry( const char* pId, const char* pDesc, const char* pExtension, fpExportFunc pFunction, unsigned int pEnforcePP = 0u)
{ {
mDescription.id = pId; mDescription.id = pId;
mDescription.description = pDesc; mDescription.description = pDesc;
mDescription.fileExtension = pExtension; mDescription.fileExtension = pExtension;
mExportFunction = pFunction; mExportFunction = pFunction;
mEnforcePP = pEnforcePP; mEnforcePP = pEnforcePP;
} }
ExportFormatEntry() : ExportFormatEntry() :
mExportFunction() mExportFunction()
, mEnforcePP() , mEnforcePP()
{ {
mDescription.id = NULL; mDescription.id = NULL;
mDescription.description = NULL; mDescription.description = NULL;
mDescription.fileExtension = NULL; mDescription.fileExtension = NULL;
} }
}; };
public: public:
Exporter(); Exporter();
~Exporter(); ~Exporter();
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Supplies a custom IO handler to the exporter to use to open and /** Supplies a custom IO handler to the exporter to use to open and
* access files. * access files.
* *
* If you need #Export to use custom IO logic to access the files, * If you need #Export to use custom IO logic to access the files,
* you need to supply a custom implementation of IOSystem and * you need to supply a custom implementation of IOSystem and
* IOFile to the exporter. * IOFile to the exporter.
* *
* #Exporter takes ownership of the object and will destroy it * #Exporter takes ownership of the object and will destroy it
* afterwards. The previously assigned handler will be deleted. * afterwards. The previously assigned handler will be deleted.
* Pass NULL to take again ownership of your IOSystem and reset Assimp * Pass NULL to take again ownership of your IOSystem and reset Assimp
* to use its default implementation, which uses plain file IO. * to use its default implementation, which uses plain file IO.
* *
* @param pIOHandler The IO handler to be used in all file accesses * @param pIOHandler The IO handler to be used in all file accesses
* of the Importer. */ * of the Importer. */
void SetIOHandler( IOSystem* pIOHandler); void SetIOHandler( IOSystem* pIOHandler);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Retrieves the IO handler that is currently set. /** Retrieves the IO handler that is currently set.
* You can use #IsDefaultIOHandler() to check whether the returned * You can use #IsDefaultIOHandler() to check whether the returned
* interface is the default IO handler provided by ASSIMP. The default * interface is the default IO handler provided by ASSIMP. The default
* handler is active as long the application doesn't supply its own * handler is active as long the application doesn't supply its own
* custom IO handler via #SetIOHandler(). * custom IO handler via #SetIOHandler().
* @return A valid IOSystem interface, never NULL. */ * @return A valid IOSystem interface, never NULL. */
IOSystem* GetIOHandler() const; IOSystem* GetIOHandler() const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Checks whether a default IO handler is active /** Checks whether a default IO handler is active
* A default handler is active as long the application doesn't * A default handler is active as long the application doesn't
* supply its own custom IO handler via #SetIOHandler(). * supply its own custom IO handler via #SetIOHandler().
* @return true by default */ * @return true by default */
bool IsDefaultIOHandler() const; bool IsDefaultIOHandler() const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Exports the given scene to a chosen file format. Returns the exported /** Exports the given scene to a chosen file format. Returns the exported
* data as a binary blob which you can write into a file or something. * data as a binary blob which you can write into a file or something.
* When you're done with the data, simply let the #Exporter instance go * When you're done with the data, simply let the #Exporter instance go
* out of scope to have it released automatically. * out of scope to have it released automatically.
* @param pScene The scene to export. Stays in possession of the caller, * @param pScene The scene to export. Stays in possession of the caller,
* is not changed by the function. * is not changed by the function.
* @param pFormatId ID string to specify to which format you want to * @param pFormatId ID string to specify to which format you want to
* export to. Use * export to. Use
* #GetExportFormatCount / #GetExportFormatDescription to learn which * #GetExportFormatCount / #GetExportFormatDescription to learn which
* export formats are available. * export formats are available.
* @param pPreprocessing See the documentation for #Export * @param pPreprocessing See the documentation for #Export
* @return the exported data or NULL in case of error. * @return the exported data or NULL in case of error.
* @note If the Exporter instance did already hold a blob from * @note If the Exporter instance did already hold a blob from
* a previous call to #ExportToBlob, it will be disposed. * a previous call to #ExportToBlob, it will be disposed.
* Any IO handlers set via #SetIOHandler are ignored here. * Any IO handlers set via #SetIOHandler are ignored here.
* @note Use aiCopyScene() to get a modifiable copy of a previously * @note Use aiCopyScene() to get a modifiable copy of a previously
* imported scene. */ * imported scene. */
const aiExportDataBlob* ExportToBlob( const aiScene* pScene, const char* pFormatId, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL); const aiExportDataBlob* ExportToBlob( const aiScene* pScene, const char* pFormatId, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
inline const aiExportDataBlob* ExportToBlob( const aiScene* pScene, const std::string& pFormatId, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL); inline const aiExportDataBlob* ExportToBlob( const aiScene* pScene, const std::string& pFormatId, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Convenience function to export directly to a file. Use /** Convenience function to export directly to a file. Use
* #SetIOSystem to supply a custom IOSystem to gain fine-grained control * #SetIOSystem to supply a custom IOSystem to gain fine-grained control
* about the output data flow of the export process. * about the output data flow of the export process.
* @param pBlob A data blob obtained from a previous call to #aiExportScene. Must not be NULL. * @param pBlob A data blob obtained from a previous call to #aiExportScene. Must not be NULL.
* @param pPath Full target file name. Target must be accessible. * @param pPath Full target file name. Target must be accessible.
* @param pPreprocessing Accepts any choice of the #aiPostProcessSteps enumerated * @param pPreprocessing Accepts any choice of the #aiPostProcessSteps enumerated
* flags, but in reality only a subset of them makes sense here. Specifying * flags, but in reality only a subset of them makes sense here. Specifying
* 'preprocessing' flags is useful if the input scene does not conform to * 'preprocessing' flags is useful if the input scene does not conform to
* Assimp's default conventions as specified in the @link data Data Structures Page @endlink. * Assimp's default conventions as specified in the @link data Data Structures Page @endlink.
* In short, this means the geometry data should use a right-handed coordinate systems, face * In short, this means the geometry data should use a right-handed coordinate systems, face
* winding should be counter-clockwise and the UV coordinate origin is assumed to be in * winding should be counter-clockwise and the UV coordinate origin is assumed to be in
* the upper left. The #aiProcess_MakeLeftHanded, #aiProcess_FlipUVs and * the upper left. The #aiProcess_MakeLeftHanded, #aiProcess_FlipUVs and
* #aiProcess_FlipWindingOrder flags are used in the import side to allow users * #aiProcess_FlipWindingOrder flags are used in the import side to allow users
* to have those defaults automatically adapted to their conventions. Specifying those flags * to have those defaults automatically adapted to their conventions. Specifying those flags
* for exporting has the opposite effect, respectively. Some other of the * for exporting has the opposite effect, respectively. Some other of the
* #aiPostProcessSteps enumerated values may be useful as well, but you'll need * #aiPostProcessSteps enumerated values may be useful as well, but you'll need
* to try out what their effect on the exported file is. Many formats impose * to try out what their effect on the exported file is. Many formats impose
* their own restrictions on the structure of the geometry stored therein, * their own restrictions on the structure of the geometry stored therein,
* so some preprocessing may have little or no effect at all, or may be * so some preprocessing may have little or no effect at all, or may be
* redundant as exporters would apply them anyhow. A good example * redundant as exporters would apply them anyhow. A good example
* is triangulation - whilst you can enforce it by specifying * is triangulation - whilst you can enforce it by specifying
* the #aiProcess_Triangulate flag, most export formats support only * the #aiProcess_Triangulate flag, most export formats support only
* triangulate data so they would run the step even if it wasn't requested. * triangulate data so they would run the step even if it wasn't requested.
* *
* If assimp detects that the input scene was directly taken from the importer side of * If assimp detects that the input scene was directly taken from the importer side of
* the library (i.e. not copied using aiCopyScene and potetially modified afterwards), * the library (i.e. not copied using aiCopyScene and potetially modified afterwards),
* any postprocessing steps already applied to the scene will not be applied again, unless * any postprocessing steps already applied to the scene will not be applied again, unless
* they show non-idempotent behaviour (#aiProcess_MakeLeftHanded, #aiProcess_FlipUVs and * they show non-idempotent behaviour (#aiProcess_MakeLeftHanded, #aiProcess_FlipUVs and
* #aiProcess_FlipWindingOrder). * #aiProcess_FlipWindingOrder).
* @return AI_SUCCESS if everything was fine. * @return AI_SUCCESS if everything was fine.
* @note Use aiCopyScene() to get a modifiable copy of a previously * @note Use aiCopyScene() to get a modifiable copy of a previously
* imported scene.*/ * imported scene.*/
aiReturn Export( const aiScene* pScene, const char* pFormatId, const char* pPath, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL); aiReturn Export( const aiScene* pScene, const char* pFormatId, const char* pPath, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
inline aiReturn Export( const aiScene* pScene, const std::string& pFormatId, const std::string& pPath, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL); inline aiReturn Export( const aiScene* pScene, const std::string& pFormatId, const std::string& pPath, unsigned int pPreprocessing = 0u, const ExportProperties* pProperties = NULL);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Returns an error description of an error that occurred in #Export /** Returns an error description of an error that occurred in #Export
* or #ExportToBlob * or #ExportToBlob
* *
* Returns an empty string if no error occurred. * Returns an empty string if no error occurred.
* @return A description of the last error, an empty string if no * @return A description of the last error, an empty string if no
* error occurred. The string is never NULL. * error occurred. The string is never NULL.
* *
* @note The returned function remains valid until one of the * @note The returned function remains valid until one of the
* following methods is called: #Export, #ExportToBlob, #FreeBlob */ * following methods is called: #Export, #ExportToBlob, #FreeBlob */
const char* GetErrorString() const; const char* GetErrorString() const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Return the blob obtained from the last call to #ExportToBlob */ /** Return the blob obtained from the last call to #ExportToBlob */
const aiExportDataBlob* GetBlob() const; const aiExportDataBlob* GetBlob() const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Orphan the blob from the last call to #ExportToBlob. This means /** Orphan the blob from the last call to #ExportToBlob. This means
* the caller takes ownership and is thus responsible for calling * the caller takes ownership and is thus responsible for calling
* the C API function #aiReleaseExportBlob to release it. */ * the C API function #aiReleaseExportBlob to release it. */
const aiExportDataBlob* GetOrphanedBlob() const; const aiExportDataBlob* GetOrphanedBlob() const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Frees the current blob. /** Frees the current blob.
* *
* The function does nothing if no blob has previously been * The function does nothing if no blob has previously been
* previously produced via #ExportToBlob. #FreeBlob is called * previously produced via #ExportToBlob. #FreeBlob is called
* automatically by the destructor. The only reason to call * automatically by the destructor. The only reason to call
* it manually would be to reclain as much storage as possible * it manually would be to reclain as much storage as possible
* without giving up the #Exporter instance yet. */ * without giving up the #Exporter instance yet. */
void FreeBlob( ); void FreeBlob( );
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Returns the number of export file formats available in the current /** Returns the number of export file formats available in the current
* Assimp build. Use #Exporter::GetExportFormatDescription to * Assimp build. Use #Exporter::GetExportFormatDescription to
* retrieve infos of a specific export format. * retrieve infos of a specific export format.
* *
* This includes built-in exporters as well as exporters registered * This includes built-in exporters as well as exporters registered
* using #RegisterExporter. * using #RegisterExporter.
**/ **/
size_t GetExportFormatCount() const; size_t GetExportFormatCount() const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Returns a description of the nth export file format. Use # /** Returns a description of the nth export file format. Use #
* #Exporter::GetExportFormatCount to learn how many export * #Exporter::GetExportFormatCount to learn how many export
* formats are supported. * formats are supported.
* *
* The returned pointer is of static storage duration iff the * The returned pointer is of static storage duration iff the
* pIndex pertains to a built-in exporter (i.e. one not registered * pIndex pertains to a built-in exporter (i.e. one not registered
* via #RegistrerExporter). It is restricted to the life-time of the * via #RegistrerExporter). It is restricted to the life-time of the
* #Exporter instance otherwise. * #Exporter instance otherwise.
* *
* @param pIndex Index of the export format to retrieve information * @param pIndex Index of the export format to retrieve information
* for. Valid range is 0 to #Exporter::GetExportFormatCount * for. Valid range is 0 to #Exporter::GetExportFormatCount
* @return A description of that specific export format. * @return A description of that specific export format.
* NULL if pIndex is out of range. */ * NULL if pIndex is out of range. */
const aiExportFormatDesc* GetExportFormatDescription( size_t pIndex ) const; const aiExportFormatDesc* GetExportFormatDescription( size_t pIndex ) const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Register a custom exporter. Custom export formats are limited to /** Register a custom exporter. Custom export formats are limited to
* to the current #Exporter instance and do not affect the * to the current #Exporter instance and do not affect the
* library globally. The indexes under which the format's * library globally. The indexes under which the format's
* export format description can be queried are assigned * export format description can be queried are assigned
* monotonously. * monotonously.
* @param desc Exporter description. * @param desc Exporter description.
* @return aiReturn_SUCCESS if the export format was successfully * @return aiReturn_SUCCESS if the export format was successfully
* registered. A common cause that would prevent an exporter * registered. A common cause that would prevent an exporter
* from being registered is that its format id is already * from being registered is that its format id is already
* occupied by another format. */ * occupied by another format. */
aiReturn RegisterExporter(const ExportFormatEntry& desc); aiReturn RegisterExporter(const ExportFormatEntry& desc);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Remove an export format previously registered with #RegisterExporter /** Remove an export format previously registered with #RegisterExporter
* from the #Exporter instance (this can also be used to drop * from the #Exporter instance (this can also be used to drop
* builtin exporters because those are implicitly registered * builtin exporters because those are implicitly registered
* using #RegisterExporter). * using #RegisterExporter).
* @param id Format id to be unregistered, this refers to the * @param id Format id to be unregistered, this refers to the
* 'id' field of #aiExportFormatDesc. * 'id' field of #aiExportFormatDesc.
* @note Calling this method on a format description not yet registered * @note Calling this method on a format description not yet registered
* has no effect.*/ * has no effect.*/
void UnregisterExporter(const char* id); void UnregisterExporter(const char* id);
protected: protected:
// Just because we don't want you to know how we're hacking around. // Just because we don't want you to know how we're hacking around.
ExporterPimpl* pimpl; ExporterPimpl* pimpl;
}; };
class ASSIMP_API ExportProperties class ASSIMP_API ExportProperties
{ {
public: public:
// Data type to store the key hash // Data type to store the key hash
typedef unsigned int KeyType; typedef unsigned int KeyType;
// typedefs for our four configuration maps. // typedefs for our four configuration maps.
// We don't need more, so there is no need for a generic solution // We don't need more, so there is no need for a generic solution
typedef std::map<KeyType, int> IntPropertyMap; typedef std::map<KeyType, int> IntPropertyMap;
typedef std::map<KeyType, float> FloatPropertyMap; typedef std::map<KeyType, float> FloatPropertyMap;
typedef std::map<KeyType, std::string> StringPropertyMap; typedef std::map<KeyType, std::string> StringPropertyMap;
typedef std::map<KeyType, aiMatrix4x4> MatrixPropertyMap; typedef std::map<KeyType, aiMatrix4x4> MatrixPropertyMap;
public: public:
/** Standard constructor /** Standard constructor
* @see ExportProperties() * @see ExportProperties()
*/ */
ExportProperties(); ExportProperties();
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Copy constructor. /** Copy constructor.
* *
* This copies the configuration properties of another ExportProperties. * This copies the configuration properties of another ExportProperties.
* @see ExportProperties(const ExportProperties& other) * @see ExportProperties(const ExportProperties& other)
*/ */
ExportProperties(const ExportProperties& other); ExportProperties(const ExportProperties& other);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Set an integer configuration property. /** Set an integer configuration property.
* @param szName Name of the property. All supported properties * @param szName Name of the property. All supported properties
* are defined in the aiConfig.g header (all constants share the * are defined in the aiConfig.g header (all constants share the
* prefix AI_CONFIG_XXX and are simple strings). * prefix AI_CONFIG_XXX and are simple strings).
* @param iValue New value of the property * @param iValue New value of the property
* @return true if the property was set before. The new value replaces * @return true if the property was set before. The new value replaces
* the previous value in this case. * the previous value in this case.
* @note Property of different types (float, int, string ..) are kept * @note Property of different types (float, int, string ..) are kept
* on different stacks, so calling SetPropertyInteger() for a * on different stacks, so calling SetPropertyInteger() for a
* floating-point property has no effect - the loader will call * floating-point property has no effect - the loader will call
* GetPropertyFloat() to read the property, but it won't be there. * GetPropertyFloat() to read the property, but it won't be there.
*/ */
bool SetPropertyInteger(const char* szName, int iValue); bool SetPropertyInteger(const char* szName, int iValue);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Set a boolean configuration property. Boolean properties /** Set a boolean configuration property. Boolean properties
* are stored on the integer stack internally so it's possible * are stored on the integer stack internally so it's possible
* to set them via #SetPropertyBool and query them with * to set them via #SetPropertyBool and query them with
* #GetPropertyBool and vice versa. * #GetPropertyBool and vice versa.
* @see SetPropertyInteger() * @see SetPropertyInteger()
*/ */
bool SetPropertyBool(const char* szName, bool value) { bool SetPropertyBool(const char* szName, bool value) {
return SetPropertyInteger(szName,value); return SetPropertyInteger(szName,value);
} }
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Set a floating-point configuration property. /** Set a floating-point configuration property.
* @see SetPropertyInteger() * @see SetPropertyInteger()
*/ */
bool SetPropertyFloat(const char* szName, float fValue); bool SetPropertyFloat(const char* szName, float fValue);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Set a string configuration property. /** Set a string configuration property.
* @see SetPropertyInteger() * @see SetPropertyInteger()
*/ */
bool SetPropertyString(const char* szName, const std::string& sValue); bool SetPropertyString(const char* szName, const std::string& sValue);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Set a matrix configuration property. /** Set a matrix configuration property.
* @see SetPropertyInteger() * @see SetPropertyInteger()
*/ */
bool SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue); bool SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Get a configuration property. /** Get a configuration property.
* @param szName Name of the property. All supported properties * @param szName Name of the property. All supported properties
* are defined in the aiConfig.g header (all constants share the * are defined in the aiConfig.g header (all constants share the
* prefix AI_CONFIG_XXX). * prefix AI_CONFIG_XXX).
* @param iErrorReturn Value that is returned if the property * @param iErrorReturn Value that is returned if the property
* is not found. * is not found.
* @return Current value of the property * @return Current value of the property
* @note Property of different types (float, int, string ..) are kept * @note Property of different types (float, int, string ..) are kept
* on different lists, so calling SetPropertyInteger() for a * on different lists, so calling SetPropertyInteger() for a
* floating-point property has no effect - the loader will call * floating-point property has no effect - the loader will call
* GetPropertyFloat() to read the property, but it won't be there. * GetPropertyFloat() to read the property, but it won't be there.
*/ */
int GetPropertyInteger(const char* szName, int GetPropertyInteger(const char* szName,
int iErrorReturn = 0xffffffff) const; int iErrorReturn = 0xffffffff) const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Get a boolean configuration property. Boolean properties /** Get a boolean configuration property. Boolean properties
* are stored on the integer stack internally so it's possible * are stored on the integer stack internally so it's possible
* to set them via #SetPropertyBool and query them with * to set them via #SetPropertyBool and query them with
* #GetPropertyBool and vice versa. * #GetPropertyBool and vice versa.
* @see GetPropertyInteger() * @see GetPropertyInteger()
*/ */
bool GetPropertyBool(const char* szName, bool bErrorReturn = false) const { bool GetPropertyBool(const char* szName, bool bErrorReturn = false) const {
return GetPropertyInteger(szName,bErrorReturn)!=0; return GetPropertyInteger(szName,bErrorReturn)!=0;
} }
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Get a floating-point configuration property /** Get a floating-point configuration property
* @see GetPropertyInteger() * @see GetPropertyInteger()
*/ */
float GetPropertyFloat(const char* szName, float GetPropertyFloat(const char* szName,
float fErrorReturn = 10e10f) const; float fErrorReturn = 10e10f) const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Get a string configuration property /** Get a string configuration property
* *
* The return value remains valid until the property is modified. * The return value remains valid until the property is modified.
* @see GetPropertyInteger() * @see GetPropertyInteger()
*/ */
const std::string GetPropertyString(const char* szName, const std::string GetPropertyString(const char* szName,
const std::string& sErrorReturn = "") const; const std::string& sErrorReturn = "") const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Get a matrix configuration property /** Get a matrix configuration property
* *
* The return value remains valid until the property is modified. * The return value remains valid until the property is modified.
* @see GetPropertyInteger() * @see GetPropertyInteger()
*/ */
const aiMatrix4x4 GetPropertyMatrix(const char* szName, const aiMatrix4x4 GetPropertyMatrix(const char* szName,
const aiMatrix4x4& sErrorReturn = aiMatrix4x4()) const; const aiMatrix4x4& sErrorReturn = aiMatrix4x4()) const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Determine a integer configuration property has been set. /** Determine a integer configuration property has been set.
* @see HasPropertyInteger() * @see HasPropertyInteger()
*/ */
bool HasPropertyInteger(const char* szName) const; bool HasPropertyInteger(const char* szName) const;
/** Determine a boolean configuration property has been set. /** Determine a boolean configuration property has been set.
* @see HasPropertyBool() * @see HasPropertyBool()
*/ */
bool HasPropertyBool(const char* szName) const; bool HasPropertyBool(const char* szName) const;
/** Determine a boolean configuration property has been set. /** Determine a boolean configuration property has been set.
* @see HasPropertyFloat() * @see HasPropertyFloat()
*/ */
bool HasPropertyFloat(const char* szName) const; bool HasPropertyFloat(const char* szName) const;
/** Determine a String configuration property has been set. /** Determine a String configuration property has been set.
* @see HasPropertyString() * @see HasPropertyString()
*/ */
bool HasPropertyString(const char* szName) const; bool HasPropertyString(const char* szName) const;
/** Determine a Matrix configuration property has been set. /** Determine a Matrix configuration property has been set.
* @see HasPropertyMatrix() * @see HasPropertyMatrix()
*/ */
bool HasPropertyMatrix(const char* szName) const; bool HasPropertyMatrix(const char* szName) const;
protected: protected:
/** List of integer properties */ /** List of integer properties */
IntPropertyMap mIntProperties; IntPropertyMap mIntProperties;
/** List of floating-point properties */ /** List of floating-point properties */
FloatPropertyMap mFloatProperties; FloatPropertyMap mFloatProperties;
/** List of string properties */ /** List of string properties */
StringPropertyMap mStringProperties; StringPropertyMap mStringProperties;
/** List of Matrix properties */ /** List of Matrix properties */
MatrixPropertyMap mMatrixProperties; MatrixPropertyMap mMatrixProperties;
}; };
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline const aiExportDataBlob* Exporter :: ExportToBlob( const aiScene* pScene, const std::string& pFormatId,unsigned int pPreprocessing, const ExportProperties* pProperties) inline const aiExportDataBlob* Exporter :: ExportToBlob( const aiScene* pScene, const std::string& pFormatId,unsigned int pPreprocessing, const ExportProperties* pProperties)
{ {
return ExportToBlob(pScene,pFormatId.c_str(),pPreprocessing, pProperties); return ExportToBlob(pScene,pFormatId.c_str(),pPreprocessing, pProperties);
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline aiReturn Exporter :: Export( const aiScene* pScene, const std::string& pFormatId, const std::string& pPath, unsigned int pPreprocessing, const ExportProperties* pProperties) inline aiReturn Exporter :: Export( const aiScene* pScene, const std::string& pFormatId, const std::string& pPath, unsigned int pPreprocessing, const ExportProperties* pProperties)
{ {
return Export(pScene,pFormatId.c_str(),pPath.c_str(),pPreprocessing, pProperties); return Export(pScene,pFormatId.c_str(),pPath.c_str(),pPreprocessing, pProperties);
} }
} // namespace Assimp } // namespace Assimp

94
include/assimp/IOStream.hpp
View File

@ -48,11 +48,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "types.h" #include "types.h"
#ifndef __cplusplus #ifndef __cplusplus
# error This header requires C++ to be used. aiFileIO.h is the \ # error This header requires C++ to be used. aiFileIO.h is the \
corresponding C interface. corresponding C interface.
#endif #endif
namespace Assimp { namespace Assimp {
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
/** @brief CPP-API: Class to handle file I/O for C++ /** @brief CPP-API: Class to handle file I/O for C++
@ -63,74 +63,74 @@ namespace Assimp {
*/ */
class ASSIMP_API IOStream class ASSIMP_API IOStream
#ifndef SWIG #ifndef SWIG
: public Intern::AllocateFromAssimpHeap : public Intern::AllocateFromAssimpHeap
#endif #endif
{ {
protected: protected:
/** Constructor protected, use IOSystem::Open() to create an instance. */ /** Constructor protected, use IOSystem::Open() to create an instance. */
IOStream(void); IOStream(void);
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Destructor. Deleting the object closes the underlying file, /** @brief Destructor. Deleting the object closes the underlying file,
* alternatively you may use IOSystem::Close() to release the file. * alternatively you may use IOSystem::Close() to release the file.
*/ */
virtual ~IOStream(); virtual ~IOStream();
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Read from the file /** @brief Read from the file
* *
* See fread() for more details * See fread() for more details
* This fails for write-only files */ * This fails for write-only files */
virtual size_t Read(void* pvBuffer, virtual size_t Read(void* pvBuffer,
size_t pSize, size_t pSize,
size_t pCount) = 0; size_t pCount) = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Write to the file /** @brief Write to the file
* *
* See fwrite() for more details * See fwrite() for more details
* This fails for read-only files */ * This fails for read-only files */
virtual size_t Write(const void* pvBuffer, virtual size_t Write(const void* pvBuffer,
size_t pSize, size_t pSize,
size_t pCount) = 0; size_t pCount) = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Set the read/write cursor of the file /** @brief Set the read/write cursor of the file
* *
* Note that the offset is _negative_ for aiOrigin_END. * Note that the offset is _negative_ for aiOrigin_END.
* See fseek() for more details */ * See fseek() for more details */
virtual aiReturn Seek(size_t pOffset, virtual aiReturn Seek(size_t pOffset,
aiOrigin pOrigin) = 0; aiOrigin pOrigin) = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Get the current position of the read/write cursor /** @brief Get the current position of the read/write cursor
* *
* See ftell() for more details */ * See ftell() for more details */
virtual size_t Tell() const = 0; virtual size_t Tell() const = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns filesize /** @brief Returns filesize
* Returns the filesize. */ * Returns the filesize. */
virtual size_t FileSize() const = 0; virtual size_t FileSize() const = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Flush the contents of the file buffer (for writers) /** @brief Flush the contents of the file buffer (for writers)
* See fflush() for more details. * See fflush() for more details.
*/ */
virtual void Flush() = 0; virtual void Flush() = 0;
}; //! class IOStream }; //! class IOStream
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline IOStream::IOStream() inline IOStream::IOStream()
{ {
// empty // empty
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline IOStream::~IOStream() inline IOStream::~IOStream()
{ {
// empty // empty
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
} //!namespace Assimp } //!namespace Assimp

202
include/assimp/IOSystem.hpp
View File

@ -48,12 +48,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define AI_IOSYSTEM_H_INC #define AI_IOSYSTEM_H_INC
#ifndef __cplusplus #ifndef __cplusplus
# error This header requires C++ to be used. aiFileIO.h is the \ # error This header requires C++ to be used. aiFileIO.h is the \
corresponding C interface. corresponding C interface.
#endif #endif
#include "types.h" #include "types.h"
namespace Assimp { namespace Assimp {
class IOStream; class IOStream;
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -66,122 +66,122 @@ class IOStream;
* @see Importer::SetIOHandler() */ * @see Importer::SetIOHandler() */
class ASSIMP_API IOSystem class ASSIMP_API IOSystem
#ifndef SWIG #ifndef SWIG
: public Intern::AllocateFromAssimpHeap : public Intern::AllocateFromAssimpHeap
#endif #endif
{ {
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Default constructor. /** @brief Default constructor.
* *
* Create an instance of your derived class and assign it to an * Create an instance of your derived class and assign it to an
* #Assimp::Importer instance by calling Importer::SetIOHandler(). * #Assimp::Importer instance by calling Importer::SetIOHandler().
*/ */
IOSystem(); IOSystem();
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Virtual destructor. /** @brief Virtual destructor.
* *
* It is safe to be called from within DLL Assimp, we're constructed * It is safe to be called from within DLL Assimp, we're constructed
* on Assimp's heap. * on Assimp's heap.
*/ */
virtual ~IOSystem(); virtual ~IOSystem();
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief For backward compatibility /** @brief For backward compatibility
* @see Exists(const char*) * @see Exists(const char*)
*/ */
AI_FORCE_INLINE bool Exists( const std::string& pFile) const; AI_FORCE_INLINE bool Exists( const std::string& pFile) const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Tests for the existence of a file at the given path. /** @brief Tests for the existence of a file at the given path.
* *
* @param pFile Path to the file * @param pFile Path to the file
* @return true if there is a file with this path, else false. * @return true if there is a file with this path, else false.
*/ */
virtual bool Exists( const char* pFile) const = 0; virtual bool Exists( const char* pFile) const = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns the system specific directory separator /** @brief Returns the system specific directory separator
* @return System specific directory separator * @return System specific directory separator
*/ */
virtual char getOsSeparator() const = 0; virtual char getOsSeparator() const = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Open a new file with a given path. /** @brief Open a new file with a given path.
* *
* When the access to the file is finished, call Close() to release * When the access to the file is finished, call Close() to release
* all associated resources (or the virtual dtor of the IOStream). * all associated resources (or the virtual dtor of the IOStream).
* *
* @param pFile Path to the file * @param pFile Path to the file
* @param pMode Desired file I/O mode. Required are: "wb", "w", "wt", * @param pMode Desired file I/O mode. Required are: "wb", "w", "wt",
* "rb", "r", "rt". * "rb", "r", "rt".
* *
* @return New IOStream interface allowing the lib to access * @return New IOStream interface allowing the lib to access
* the underlying file. * the underlying file.
* @note When implementing this class to provide custom IO handling, * @note When implementing this class to provide custom IO handling,
* you probably have to supply an own implementation of IOStream as well. * you probably have to supply an own implementation of IOStream as well.
*/ */
virtual IOStream* Open(const char* pFile, virtual IOStream* Open(const char* pFile,
const char* pMode = "rb") = 0; const char* pMode = "rb") = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief For backward compatibility /** @brief For backward compatibility
* @see Open(const char*, const char*) * @see Open(const char*, const char*)
*/ */
inline IOStream* Open(const std::string& pFile, inline IOStream* Open(const std::string& pFile,
const std::string& pMode = std::string("rb")); const std::string& pMode = std::string("rb"));
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Closes the given file and releases all resources /** @brief Closes the given file and releases all resources
* associated with it. * associated with it.
* @param pFile The file instance previously created by Open(). * @param pFile The file instance previously created by Open().
*/ */
virtual void Close( IOStream* pFile) = 0; virtual void Close( IOStream* pFile) = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Compares two paths and check whether the point to /** @brief Compares two paths and check whether the point to
* identical files. * identical files.
* *
* The dummy implementation of this virtual member performs a * The dummy implementation of this virtual member performs a
* case-insensitive comparison of the given strings. The default IO * case-insensitive comparison of the given strings. The default IO
* system implementation uses OS mechanisms to convert relative into * system implementation uses OS mechanisms to convert relative into
* absolute paths, so the result can be trusted. * absolute paths, so the result can be trusted.
* @param one First file * @param one First file
* @param second Second file * @param second Second file
* @return true if the paths point to the same file. The file needn't * @return true if the paths point to the same file. The file needn't
* be existing, however. * be existing, however.
*/ */
virtual bool ComparePaths (const char* one, virtual bool ComparePaths (const char* one,
const char* second) const; const char* second) const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief For backward compatibility /** @brief For backward compatibility
* @see ComparePaths(const char*, const char*) * @see ComparePaths(const char*, const char*)
*/ */
inline bool ComparePaths (const std::string& one, inline bool ComparePaths (const std::string& one,
const std::string& second) const; const std::string& second) const;
}; };
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
AI_FORCE_INLINE IOSystem::IOSystem() AI_FORCE_INLINE IOSystem::IOSystem()
{ {
// empty // empty
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
AI_FORCE_INLINE IOSystem::~IOSystem() AI_FORCE_INLINE IOSystem::~IOSystem()
{ {
// empty // empty
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@ -192,31 +192,31 @@ AI_FORCE_INLINE IOSystem::~IOSystem()
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
AI_FORCE_INLINE IOStream* IOSystem::Open(const std::string& pFile, AI_FORCE_INLINE IOStream* IOSystem::Open(const std::string& pFile,
const std::string& pMode) const std::string& pMode)
{ {
// NOTE: // NOTE:
// For compatibility, interface was changed to const char* to // For compatibility, interface was changed to const char* to
// avoid crashes between binary incompatible STL versions // avoid crashes between binary incompatible STL versions
return Open(pFile.c_str(),pMode.c_str()); return Open(pFile.c_str(),pMode.c_str());
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
AI_FORCE_INLINE bool IOSystem::Exists( const std::string& pFile) const AI_FORCE_INLINE bool IOSystem::Exists( const std::string& pFile) const
{ {
// NOTE: // NOTE:
// For compatibility, interface was changed to const char* to // For compatibility, interface was changed to const char* to
// avoid crashes between binary incompatible STL versions // avoid crashes between binary incompatible STL versions
return Exists(pFile.c_str()); return Exists(pFile.c_str());
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
inline bool IOSystem::ComparePaths (const std::string& one, inline bool IOSystem::ComparePaths (const std::string& one,
const std::string& second) const const std::string& second) const
{ {
// NOTE: // NOTE:
// For compatibility, interface was changed to const char* to // For compatibility, interface was changed to const char* to
// avoid crashes between binary incompatible STL versions // avoid crashes between binary incompatible STL versions
return ComparePaths(one.c_str(),second.c_str()); return ComparePaths(one.c_str(),second.c_str());
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

970
include/assimp/Importer.hpp
View File

File diff suppressed because it is too large Load Diff

56
include/assimp/LogStream.hpp
View File

@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef INCLUDED_AI_LOGSTREAM_H #ifndef INCLUDED_AI_LOGSTREAM_H
#define INCLUDED_AI_LOGSTREAM_H #define INCLUDED_AI_LOGSTREAM_H
#include "types.h" #include "types.h"
namespace Assimp { namespace Assimp {
class IOSystem; class IOSystem;
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
@ -55,39 +55,39 @@ class IOSystem;
* are not enough for your purpose. */ * are not enough for your purpose. */
class ASSIMP_API LogStream class ASSIMP_API LogStream
#ifndef SWIG #ifndef SWIG
: public Intern::AllocateFromAssimpHeap : public Intern::AllocateFromAssimpHeap
#endif #endif
{ {
protected: protected:
/** @brief Default constructor */ /** @brief Default constructor */
LogStream() { LogStream() {
} }
public: public:
/** @brief Virtual destructor */ /** @brief Virtual destructor */
virtual ~LogStream() { virtual ~LogStream() {
} }
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Overwrite this for your own output methods /** @brief Overwrite this for your own output methods
* *
* Log messages *may* consist of multiple lines and you shouldn't * Log messages *may* consist of multiple lines and you shouldn't
* expect a consistent formatting. If you want custom formatting * expect a consistent formatting. If you want custom formatting
* (e.g. generate HTML), supply a custom instance of Logger to * (e.g. generate HTML), supply a custom instance of Logger to
* #DefaultLogger:set(). Usually you can *expect* that a log message * #DefaultLogger:set(). Usually you can *expect* that a log message
* is exactly one line and terminated with a single \n character. * is exactly one line and terminated with a single \n character.
* @param message Message to be written */ * @param message Message to be written */
virtual void write(const char* message) = 0; virtual void write(const char* message) = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Creates a default log stream /** @brief Creates a default log stream
* @param streams Type of the default stream * @param streams Type of the default stream
* @param name For aiDefaultLogStream_FILE: name of the output file * @param name For aiDefaultLogStream_FILE: name of the output file
* @param io For aiDefaultLogStream_FILE: IOSystem to be used to open the output * @param io For aiDefaultLogStream_FILE: IOSystem to be used to open the output
* file. Pass NULL for the default implementation. * file. Pass NULL for the default implementation.
* @return New LogStream instance. */ * @return New LogStream instance. */
static LogStream* createDefaultStream(aiDefaultLogStream stream, static LogStream* createDefaultStream(aiDefaultLogStream stream,
const char* name = "AssimpLog.txt", const char* name = "AssimpLog.txt",
IOSystem* io = NULL); IOSystem* io = NULL);
}; // !class LogStream }; // !class LogStream
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------

262
include/assimp/Logger.hpp
View File

@ -45,217 +45,217 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define INCLUDED_AI_LOGGER_H #define INCLUDED_AI_LOGGER_H
#include "types.h" #include "types.h"
namespace Assimp { namespace Assimp {
class LogStream; class LogStream;
// Maximum length of a log message. Longer messages are rejected. // Maximum length of a log message. Longer messages are rejected.
#define MAX_LOG_MESSAGE_LENGTH 1024u #define MAX_LOG_MESSAGE_LENGTH 1024u
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
/** @brief CPP-API: Abstract interface for logger implementations. /** @brief CPP-API: Abstract interface for logger implementations.
* Assimp provides a default implementation and uses it for almost all * Assimp provides a default implementation and uses it for almost all
* logging stuff ('DefaultLogger'). This class defines just basic logging * logging stuff ('DefaultLogger'). This class defines just basic logging
* behaviour and is not of interest for you. Instead, take a look at #DefaultLogger. */ * behaviour and is not of interest for you. Instead, take a look at #DefaultLogger. */
class ASSIMP_API Logger class ASSIMP_API Logger
#ifndef SWIG #ifndef SWIG
: public Intern::AllocateFromAssimpHeap : public Intern::AllocateFromAssimpHeap
#endif #endif
{ {
public: public:
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @enum LogSeverity /** @enum LogSeverity
* @brief Log severity to describe the granularity of logging. * @brief Log severity to describe the granularity of logging.
*/ */
enum LogSeverity enum LogSeverity
{ {
NORMAL, //!< Normal granularity of logging NORMAL, //!< Normal granularity of logging
VERBOSE //!< Debug infos will be logged, too VERBOSE //!< Debug infos will be logged, too
}; };
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @enum ErrorSeverity /** @enum ErrorSeverity
* @brief Description for severity of a log message. * @brief Description for severity of a log message.
* *
* Every LogStream has a bitwise combination of these flags. * Every LogStream has a bitwise combination of these flags.
* A LogStream doesn't receive any messages of a specific type * A LogStream doesn't receive any messages of a specific type
* if it doesn't specify the corresponding ErrorSeverity flag. * if it doesn't specify the corresponding ErrorSeverity flag.
*/ */
enum ErrorSeverity enum ErrorSeverity
{ {
Debugging = 1, //!< Debug log message Debugging = 1, //!< Debug log message
Info = 2, //!< Info log message Info = 2, //!< Info log message
Warn = 4, //!< Warn log message Warn = 4, //!< Warn log message
Err = 8 //!< Error log message Err = 8 //!< Error log message
}; };
public: public:
/** @brief Virtual destructor */ /** @brief Virtual destructor */
virtual ~Logger(); virtual ~Logger();
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Writes a debug message /** @brief Writes a debug message
* @param message Debug message*/ * @param message Debug message*/
void debug(const char* message); void debug(const char* message);
inline void debug(const std::string &message); inline void debug(const std::string &message);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Writes a info message /** @brief Writes a info message
* @param message Info message*/ * @param message Info message*/
void info(const char* message); void info(const char* message);
inline void info(const std::string &message); inline void info(const std::string &message);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Writes a warning message /** @brief Writes a warning message
* @param message Warn message*/ * @param message Warn message*/
void warn(const char* message); void warn(const char* message);
inline void warn(const std::string &message); inline void warn(const std::string &message);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Writes an error message /** @brief Writes an error message
* @param message Error message*/ * @param message Error message*/
void error(const char* message); void error(const char* message);
inline void error(const std::string &message); inline void error(const std::string &message);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Set a new log severity. /** @brief Set a new log severity.
* @param log_severity New severity for logging*/ * @param log_severity New severity for logging*/
void setLogSeverity(LogSeverity log_severity); void setLogSeverity(LogSeverity log_severity);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Get the current log severity*/ /** @brief Get the current log severity*/
LogSeverity getLogSeverity() const; LogSeverity getLogSeverity() const;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Attach a new log-stream /** @brief Attach a new log-stream
* *
* The logger takes ownership of the stream and is responsible * The logger takes ownership of the stream and is responsible
* for its destruction (which is done using ::delete when the logger * for its destruction (which is done using ::delete when the logger
* itself is destroyed). Call detachStream to detach a stream and to * itself is destroyed). Call detachStream to detach a stream and to
* gain ownership of it again. * gain ownership of it again.
* @param pStream Log-stream to attach * @param pStream Log-stream to attach
* @param severity Message filter, specified which types of log * @param severity Message filter, specified which types of log
* messages are dispatched to the stream. Provide a bitwise * messages are dispatched to the stream. Provide a bitwise
* combination of the ErrorSeverity flags. * combination of the ErrorSeverity flags.
* @return true if the stream has been attached, false otherwise.*/ * @return true if the stream has been attached, false otherwise.*/
virtual bool attachStream(LogStream *pStream, virtual bool attachStream(LogStream *pStream,
unsigned int severity = Debugging | Err | Warn | Info) = 0; unsigned int severity = Debugging | Err | Warn | Info) = 0;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Detach a still attached stream from the logger (or /** @brief Detach a still attached stream from the logger (or
* modify the filter flags bits) * modify the filter flags bits)
* @param pStream Log-stream instance for detaching * @param pStream Log-stream instance for detaching
* @param severity Provide a bitwise combination of the ErrorSeverity * @param severity Provide a bitwise combination of the ErrorSeverity
* flags. This value is &~ed with the current flags of the stream, * flags. This value is &~ed with the current flags of the stream,
* if the result is 0 the stream is detached from the Logger and * if the result is 0 the stream is detached from the Logger and
* the caller retakes the possession of the stream. * the caller retakes the possession of the stream.
* @return true if the stream has been detached, false otherwise.*/ * @return true if the stream has been detached, false otherwise.*/
virtual bool detatchStream(LogStream *pStream, virtual bool detatchStream(LogStream *pStream,
unsigned int severity = Debugging | Err | Warn | Info) = 0; unsigned int severity = Debugging | Err | Warn | Info) = 0;
protected: protected:
/** Default constructor */ /** Default constructor */
Logger(); Logger();
/** Construction with a given log severity */ /** Construction with a given log severity */
Logger(LogSeverity severity); Logger(LogSeverity severity);
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Called as a request to write a specific debug message /** @brief Called as a request to write a specific debug message
* @param message Debug message. Never longer than * @param message Debug message. Never longer than
* MAX_LOG_MESSAGE_LENGTH characters (excluding the '0'). * MAX_LOG_MESSAGE_LENGTH characters (excluding the '0').
* @note The message string is only valid until the scope of * @note The message string is only valid until the scope of
* the function is left. * the function is left.
*/ */
virtual void OnDebug(const char* message)= 0; virtual void OnDebug(const char* message)= 0;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Called as a request to write a specific info message /** @brief Called as a request to write a specific info message
* @param message Info message. Never longer than * @param message Info message. Never longer than
* MAX_LOG_MESSAGE_LENGTH characters (ecxluding the '0'). * MAX_LOG_MESSAGE_LENGTH characters (ecxluding the '0').
* @note The message string is only valid until the scope of * @note The message string is only valid until the scope of
* the function is left. * the function is left.
*/ */
virtual void OnInfo(const char* message) = 0; virtual void OnInfo(const char* message) = 0;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Called as a request to write a specific warn message /** @brief Called as a request to write a specific warn message
* @param message Warn message. Never longer than * @param message Warn message. Never longer than
* MAX_LOG_MESSAGE_LENGTH characters (exluding the '0'). * MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
* @note The message string is only valid until the scope of * @note The message string is only valid until the scope of
* the function is left. * the function is left.
*/ */
virtual void OnWarn(const char* essage) = 0; virtual void OnWarn(const char* essage) = 0;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
/** @brief Called as a request to write a specific error message /** @brief Called as a request to write a specific error message
* @param message Error message. Never longer than * @param message Error message. Never longer than
* MAX_LOG_MESSAGE_LENGTH characters (exluding the '0'). * MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
* @note The message string is only valid until the scope of * @note The message string is only valid until the scope of
* the function is left. * the function is left.
*/ */
virtual void OnError(const char* message) = 0; virtual void OnError(const char* message) = 0;
protected: protected:
//! Logger severity //! Logger severity
LogSeverity m_Severity; LogSeverity m_Severity;
}; };
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
// Default constructor // Default constructor
inline Logger::Logger() { inline Logger::Logger() {
setLogSeverity(NORMAL); setLogSeverity(NORMAL);
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
// Virtual destructor // Virtual destructor
inline Logger::~Logger() inline Logger::~Logger()
{ {
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
// Construction with given logging severity // Construction with given logging severity
inline Logger::Logger(LogSeverity severity) { inline Logger::Logger(LogSeverity severity) {
setLogSeverity(severity); setLogSeverity(severity);
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
// Log severity setter // Log severity setter
inline void Logger::setLogSeverity(LogSeverity log_severity){ inline void Logger::setLogSeverity(LogSeverity log_severity){
m_Severity = log_severity; m_Severity = log_severity;
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
// Log severity getter // Log severity getter
inline Logger::LogSeverity Logger::getLogSeverity() const { inline Logger::LogSeverity Logger::getLogSeverity() const {
return m_Severity; return m_Severity;
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline void Logger::debug(const std::string &message) inline void Logger::debug(const std::string &message)
{ {
return debug(message.c_str()); return debug(message.c_str());
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline void Logger::error(const std::string &message) inline void Logger::error(const std::string &message)
{ {
return error(message.c_str()); return error(message.c_str());
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline void Logger::warn(const std::string &message) inline void Logger::warn(const std::string &message)
{ {
return warn(message.c_str()); return warn(message.c_str());
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
inline void Logger::info(const std::string &message) inline void Logger::info(const std::string &message)
{ {
return info(message.c_str()); return info(message.c_str());
} }
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------

56
include/assimp/NullLogger.hpp
View File

@ -46,48 +46,48 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define INCLUDED_AI_NULLLOGGER_H #define INCLUDED_AI_NULLLOGGER_H
#include "Logger.hpp" #include "Logger.hpp"
namespace Assimp { namespace Assimp {
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief CPP-API: Empty logging implementation. /** @brief CPP-API: Empty logging implementation.
* *
* Does nothing! Used by default if the application hasn't requested a * Does nothing! Used by default if the application hasn't requested a
* custom logger via #DefaultLogger::set() or #DefaultLogger::create(); */ * custom logger via #DefaultLogger::set() or #DefaultLogger::create(); */
class ASSIMP_API NullLogger class ASSIMP_API NullLogger
: public Logger { : public Logger {
public: public:
/** @brief Logs a debug message */ /** @brief Logs a debug message */
void OnDebug(const char* message) { void OnDebug(const char* message) {
(void)message; //this avoids compiler warnings (void)message; //this avoids compiler warnings
} }
/** @brief Logs an info message */ /** @brief Logs an info message */
void OnInfo(const char* message) { void OnInfo(const char* message) {
(void)message; //this avoids compiler warnings (void)message; //this avoids compiler warnings
} }
/** @brief Logs a warning message */ /** @brief Logs a warning message */
void OnWarn(const char* message) { void OnWarn(const char* message) {
(void)message; //this avoids compiler warnings (void)message; //this avoids compiler warnings
} }
/** @brief Logs an error message */ /** @brief Logs an error message */
void OnError(const char* message) { void OnError(const char* message) {
(void)message; //this avoids compiler warnings (void)message; //this avoids compiler warnings
} }
/** @brief Detach a still attached stream from logger */ /** @brief Detach a still attached stream from logger */
bool attachStream(LogStream *pStream, unsigned int severity) { bool attachStream(LogStream *pStream, unsigned int severity) {
(void)pStream; (void)severity; //this avoids compiler warnings (void)pStream; (void)severity; //this avoids compiler warnings
return false; return false;
} }
/** @brief Detach a still attached stream from logger */ /** @brief Detach a still attached stream from logger */
bool detatchStream(LogStream *pStream, unsigned int severity) { bool detatchStream(LogStream *pStream, unsigned int severity) {
(void)pStream; (void)severity; //this avoids compiler warnings (void)pStream; (void)severity; //this avoids compiler warnings
return false; return false;
} }
private: private:
}; };

110
include/assimp/ProgressHandler.hpp
View File

@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef INCLUDED_AI_PROGRESSHANDLER_H #ifndef INCLUDED_AI_PROGRESSHANDLER_H
#define INCLUDED_AI_PROGRESSHANDLER_H #define INCLUDED_AI_PROGRESSHANDLER_H
#include "types.h" #include "types.h"
namespace Assimp { namespace Assimp {
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
/** @brief CPP-API: Abstract interface for custom progress report receivers. /** @brief CPP-API: Abstract interface for custom progress report receivers.
@ -53,67 +53,67 @@ namespace Assimp {
* implementation provided by Assimp doesn't do anything at all. */ * implementation provided by Assimp doesn't do anything at all. */
class ASSIMP_API ProgressHandler class ASSIMP_API ProgressHandler
#ifndef SWIG #ifndef SWIG
: public Intern::AllocateFromAssimpHeap : public Intern::AllocateFromAssimpHeap
#endif #endif
{ {
protected: protected:
/** @brief Default constructor */ /** @brief Default constructor */
ProgressHandler () { ProgressHandler () {
} }
public: public:
/** @brief Virtual destructor */ /** @brief Virtual destructor */
virtual ~ProgressHandler () { virtual ~ProgressHandler () {
} }
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Progress callback. /** @brief Progress callback.
* @param percentage An estimate of the current loading progress, * @param percentage An estimate of the current loading progress,
* in percent. Or -1.f if such an estimate is not available. * in percent. Or -1.f if such an estimate is not available.
* *
* There are restriction on what you may do from within your * There are restriction on what you may do from within your
* implementation of this method: no exceptions may be thrown and no * implementation of this method: no exceptions may be thrown and no
* non-const #Importer methods may be called. It is * non-const #Importer methods may be called. It is
* not generally possible to predict the number of callbacks * not generally possible to predict the number of callbacks
* fired during a single import. * fired during a single import.
* *
* @return Return false to abort loading at the next possible * @return Return false to abort loading at the next possible
* occasion (loaders and Assimp are generally allowed to perform * occasion (loaders and Assimp are generally allowed to perform
* all needed cleanup tasks prior to returning control to the * all needed cleanup tasks prior to returning control to the
* caller). If the loading is aborted, #Importer::ReadFile() * caller). If the loading is aborted, #Importer::ReadFile()
* returns always NULL. * returns always NULL.
* */ * */
virtual bool Update(float percentage = -1.f) = 0; virtual bool Update(float percentage = -1.f) = 0;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Progress callback for file loading steps /** @brief Progress callback for file loading steps
* @param numberOfSteps The number of total post-processing * @param numberOfSteps The number of total post-processing
* steps * steps
* @param currentStep The index of the current post-processing * @param currentStep The index of the current post-processing
* step that will run, or equal to numberOfSteps if all of * step that will run, or equal to numberOfSteps if all of
* them has finished. This number is always strictly monotone * them has finished. This number is always strictly monotone
* increasing, although not necessarily linearly. * increasing, although not necessarily linearly.
* *
* @note This is currently only used at the start and the end * @note This is currently only used at the start and the end
* of the file parsing. * of the file parsing.
* */ * */
virtual void UpdateFileRead(int currentStep /*= 0*/, int numberOfSteps /*= 0*/) { virtual void UpdateFileRead(int currentStep /*= 0*/, int numberOfSteps /*= 0*/) {
float f = numberOfSteps ? currentStep / (float)numberOfSteps : 1.0f; float f = numberOfSteps ? currentStep / (float)numberOfSteps : 1.0f;
Update( f * 0.5f ); Update( f * 0.5f );
} }
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Progress callback for post-processing steps /** @brief Progress callback for post-processing steps
* @param numberOfSteps The number of total post-processing * @param numberOfSteps The number of total post-processing
* steps * steps
* @param currentStep The index of the current post-processing * @param currentStep The index of the current post-processing
* step that will run, or equal to numberOfSteps if all of * step that will run, or equal to numberOfSteps if all of
* them has finished. This number is always strictly monotone * them has finished. This number is always strictly monotone
* increasing, although not necessarily linearly. * increasing, although not necessarily linearly.
* */ * */
virtual void UpdatePostProcess(int currentStep /*= 0*/, int numberOfSteps /*= 0*/) { virtual void UpdatePostProcess(int currentStep /*= 0*/, int numberOfSteps /*= 0*/) {
float f = numberOfSteps ? currentStep / (float)numberOfSteps : 1.0f; float f = numberOfSteps ? currentStep / (float)numberOfSteps : 1.0f;
Update( f * 0.5f + 0.5f ); Update( f * 0.5f + 0.5f );
} }
}; // !class ProgressHandler }; // !class ProgressHandler
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------

6
include/assimp/ai_assert.h
View File

@ -4,10 +4,10 @@
#define AI_DEBUG_H_INC #define AI_DEBUG_H_INC
#ifdef ASSIMP_BUILD_DEBUG #ifdef ASSIMP_BUILD_DEBUG
# include <assert.h> # include <assert.h>
# define ai_assert(expression) assert(expression) # define ai_assert(expression) assert(expression)
#else #else
# define ai_assert(expression) # define ai_assert(expression)
#endif #endif

506
include/assimp/anim.h
View File

@ -57,41 +57,41 @@ extern "C" {
/** A time-value pair specifying a certain 3D vector for the given time. */ /** A time-value pair specifying a certain 3D vector for the given time. */
struct aiVectorKey struct aiVectorKey
{ {
/** The time of this key */ /** The time of this key */
double mTime; double mTime;
/** The value of this key */ /** The value of this key */
C_STRUCT aiVector3D mValue; C_STRUCT aiVector3D mValue;
#ifdef __cplusplus #ifdef __cplusplus
//! Default constructor //! Default constructor
aiVectorKey(){} aiVectorKey(){}
//! Construction from a given time and key value //! Construction from a given time and key value
aiVectorKey(double time, const aiVector3D& value) aiVectorKey(double time, const aiVector3D& value)
: mTime (time) : mTime (time)
, mValue (value) , mValue (value)
{} {}
typedef aiVector3D elem_type; typedef aiVector3D elem_type;
// Comparison operators. For use with std::find(); // Comparison operators. For use with std::find();
bool operator == (const aiVectorKey& o) const { bool operator == (const aiVectorKey& o) const {
return o.mValue == this->mValue; return o.mValue == this->mValue;
} }
bool operator != (const aiVectorKey& o) const { bool operator != (const aiVectorKey& o) const {
return o.mValue != this->mValue; return o.mValue != this->mValue;
} }
// Relational operators. For use with std::sort(); // Relational operators. For use with std::sort();
bool operator < (const aiVectorKey& o) const { bool operator < (const aiVectorKey& o) const {
return mTime < o.mTime; return mTime < o.mTime;
} }
bool operator > (const aiVectorKey& o) const { bool operator > (const aiVectorKey& o) const {
return mTime > o.mTime; return mTime > o.mTime;
} }
#endif #endif
}; };
@ -100,39 +100,39 @@ struct aiVectorKey
* Rotations are expressed with quaternions. */ * Rotations are expressed with quaternions. */
struct aiQuatKey struct aiQuatKey
{ {
/** The time of this key */ /** The time of this key */
double mTime; double mTime;
/** The value of this key */ /** The value of this key */
C_STRUCT aiQuaternion mValue; C_STRUCT aiQuaternion mValue;
#ifdef __cplusplus #ifdef __cplusplus
aiQuatKey(){ aiQuatKey(){
} }
/** Construction from a given time and key value */ /** Construction from a given time and key value */
aiQuatKey(double time, const aiQuaternion& value) aiQuatKey(double time, const aiQuaternion& value)
: mTime (time) : mTime (time)
, mValue (value) , mValue (value)
{} {}
typedef aiQuaternion elem_type; typedef aiQuaternion elem_type;
// Comparison operators. For use with std::find(); // Comparison operators. For use with std::find();
bool operator == (const aiQuatKey& o) const { bool operator == (const aiQuatKey& o) const {
return o.mValue == this->mValue; return o.mValue == this->mValue;
} }
bool operator != (const aiQuatKey& o) const { bool operator != (const aiQuatKey& o) const {
return o.mValue != this->mValue; return o.mValue != this->mValue;
} }
// Relational operators. For use with std::sort(); // Relational operators. For use with std::sort();
bool operator < (const aiQuatKey& o) const { bool operator < (const aiQuatKey& o) const {
return mTime < o.mTime; return mTime < o.mTime;
} }
bool operator > (const aiQuatKey& o) const { bool operator > (const aiQuatKey& o) const {
return mTime > o.mTime; return mTime > o.mTime;
} }
#endif #endif
}; };
@ -140,43 +140,43 @@ struct aiQuatKey
/** Binds a anim mesh to a specific point in time. */ /** Binds a anim mesh to a specific point in time. */
struct aiMeshKey struct aiMeshKey
{ {
/** The time of this key */ /** The time of this key */
double mTime; double mTime;
/** Index into the aiMesh::mAnimMeshes array of the /** Index into the aiMesh::mAnimMeshes array of the
* mesh coresponding to the #aiMeshAnim hosting this * mesh coresponding to the #aiMeshAnim hosting this
* key frame. The referenced anim mesh is evaluated * key frame. The referenced anim mesh is evaluated
* according to the rules defined in the docs for #aiAnimMesh.*/ * according to the rules defined in the docs for #aiAnimMesh.*/
unsigned int mValue; unsigned int mValue;
#ifdef __cplusplus #ifdef __cplusplus
aiMeshKey() { aiMeshKey() {
} }
/** Construction from a given time and key value */ /** Construction from a given time and key value */
aiMeshKey(double time, const unsigned int value) aiMeshKey(double time, const unsigned int value)
: mTime (time) : mTime (time)
, mValue (value) , mValue (value)
{} {}
typedef unsigned int elem_type; typedef unsigned int elem_type;
// Comparison operators. For use with std::find(); // Comparison operators. For use with std::find();
bool operator == (const aiMeshKey& o) const { bool operator == (const aiMeshKey& o) const {
return o.mValue == this->mValue; return o.mValue == this->mValue;
} }
bool operator != (const aiMeshKey& o) const { bool operator != (const aiMeshKey& o) const {
return o.mValue != this->mValue; return o.mValue != this->mValue;
} }
// Relational operators. For use with std::sort(); // Relational operators. For use with std::sort();
bool operator < (const aiMeshKey& o) const { bool operator < (const aiMeshKey& o) const {
return mTime < o.mTime; return mTime < o.mTime;
} }
bool operator > (const aiMeshKey& o) const { bool operator > (const aiMeshKey& o) const {
return mTime > o.mTime; return mTime > o.mTime;
} }
#endif #endif
}; };
@ -187,28 +187,28 @@ struct aiMeshKey
* aiNodeAnim::mPostState.*/ * aiNodeAnim::mPostState.*/
enum aiAnimBehaviour enum aiAnimBehaviour
{ {
/** The value from the default node transformation is taken*/ /** The value from the default node transformation is taken*/
aiAnimBehaviour_DEFAULT = 0x0, aiAnimBehaviour_DEFAULT = 0x0,
/** The nearest key value is used without interpolation */ /** The nearest key value is used without interpolation */
aiAnimBehaviour_CONSTANT = 0x1, aiAnimBehaviour_CONSTANT = 0x1,
/** The value of the nearest two keys is linearly /** The value of the nearest two keys is linearly
* extrapolated for the current time value.*/ * extrapolated for the current time value.*/
aiAnimBehaviour_LINEAR = 0x2, aiAnimBehaviour_LINEAR = 0x2,
/** The animation is repeated. /** The animation is repeated.
* *
* If the animation key go from n to m and the current * If the animation key go from n to m and the current
* time is t, use the value at (t-n) % (|m-n|).*/ * time is t, use the value at (t-n) % (|m-n|).*/
aiAnimBehaviour_REPEAT = 0x3, aiAnimBehaviour_REPEAT = 0x3,
/** This value is not used, it is just here to force the /** This value is not used, it is just here to force the
* the compiler to map this enum to a 32 Bit integer */ * the compiler to map this enum to a 32 Bit integer */
#ifndef SWIG #ifndef SWIG
_aiAnimBehaviour_Force32Bit = INT_MAX _aiAnimBehaviour_Force32Bit = INT_MAX
#endif #endif
}; };
@ -229,73 +229,73 @@ enum aiAnimBehaviour
* implementations need to cope with them! ) */ * implementations need to cope with them! ) */
struct aiNodeAnim struct aiNodeAnim
{ {
/** The name of the node affected by this animation. The node /** The name of the node affected by this animation. The node
* must exist and it must be unique.*/ * must exist and it must be unique.*/
C_STRUCT aiString mNodeName; C_STRUCT aiString mNodeName;
/** The number of position keys */ /** The number of position keys */
unsigned int mNumPositionKeys; unsigned int mNumPositionKeys;
/** The position keys of this animation channel. Positions are /** The position keys of this animation channel. Positions are
* specified as 3D vector. The array is mNumPositionKeys in size. * specified as 3D vector. The array is mNumPositionKeys in size.
* *
* If there are position keys, there will also be at least one * If there are position keys, there will also be at least one
* scaling and one rotation key.*/ * scaling and one rotation key.*/
C_STRUCT aiVectorKey* mPositionKeys; C_STRUCT aiVectorKey* mPositionKeys;
/** The number of rotation keys */ /** The number of rotation keys */
unsigned int mNumRotationKeys; unsigned int mNumRotationKeys;
/** The rotation keys of this animation channel. Rotations are /** The rotation keys of this animation channel. Rotations are
* given as quaternions, which are 4D vectors. The array is * given as quaternions, which are 4D vectors. The array is
* mNumRotationKeys in size. * mNumRotationKeys in size.
* *
* If there are rotation keys, there will also be at least one * If there are rotation keys, there will also be at least one
* scaling and one position key. */ * scaling and one position key. */
C_STRUCT aiQuatKey* mRotationKeys; C_STRUCT aiQuatKey* mRotationKeys;
/** The number of scaling keys */ /** The number of scaling keys */
unsigned int mNumScalingKeys; unsigned int mNumScalingKeys;
/** The scaling keys of this animation channel. Scalings are /** The scaling keys of this animation channel. Scalings are
* specified as 3D vector. The array is mNumScalingKeys in size. * specified as 3D vector. The array is mNumScalingKeys in size.
* *
* If there are scaling keys, there will also be at least one * If there are scaling keys, there will also be at least one
* position and one rotation key.*/ * position and one rotation key.*/
C_STRUCT aiVectorKey* mScalingKeys; C_STRUCT aiVectorKey* mScalingKeys;
/** Defines how the animation behaves before the first /** Defines how the animation behaves before the first
* key is encountered. * key is encountered.
* *
* The default value is aiAnimBehaviour_DEFAULT (the original * The default value is aiAnimBehaviour_DEFAULT (the original
* transformation matrix of the affected node is used).*/ * transformation matrix of the affected node is used).*/
C_ENUM aiAnimBehaviour mPreState; C_ENUM aiAnimBehaviour mPreState;
/** Defines how the animation behaves after the last /** Defines how the animation behaves after the last
* key was processed. * key was processed.
* *
* The default value is aiAnimBehaviour_DEFAULT (the original * The default value is aiAnimBehaviour_DEFAULT (the original
* transformation matrix of the affected node is taken).*/ * transformation matrix of the affected node is taken).*/
C_ENUM aiAnimBehaviour mPostState; C_ENUM aiAnimBehaviour mPostState;
#ifdef __cplusplus #ifdef __cplusplus
aiNodeAnim() aiNodeAnim()
{ {
mNumPositionKeys = 0; mPositionKeys = NULL; mNumPositionKeys = 0; mPositionKeys = NULL;
mNumRotationKeys = 0; mRotationKeys = NULL; mNumRotationKeys = 0; mRotationKeys = NULL;
mNumScalingKeys = 0; mScalingKeys = NULL; mNumScalingKeys = 0; mScalingKeys = NULL;
mPreState = mPostState = aiAnimBehaviour_DEFAULT; mPreState = mPostState = aiAnimBehaviour_DEFAULT;
} }
~aiNodeAnim() ~aiNodeAnim()
{ {
delete [] mPositionKeys; delete [] mPositionKeys;
delete [] mRotationKeys; delete [] mRotationKeys;
delete [] mScalingKeys; delete [] mScalingKeys;
} }
#endif // __cplusplus #endif // __cplusplus
}; };
@ -307,29 +307,29 @@ struct aiNodeAnim
* point in time. */ * point in time. */
struct aiMeshAnim struct aiMeshAnim
{ {
/** Name of the mesh to be animated. An empty string is not allowed, /** Name of the mesh to be animated. An empty string is not allowed,
* animated meshes need to be named (not necessarily uniquely, * animated meshes need to be named (not necessarily uniquely,
* the name can basically serve as wildcard to select a group * the name can basically serve as wildcard to select a group
* of meshes with similar animation setup)*/ * of meshes with similar animation setup)*/
C_STRUCT aiString mName; C_STRUCT aiString mName;
/** Size of the #mKeys array. Must be 1, at least. */ /** Size of the #mKeys array. Must be 1, at least. */
unsigned int mNumKeys; unsigned int mNumKeys;
/** Key frames of the animation. May not be NULL. */ /** Key frames of the animation. May not be NULL. */
C_STRUCT aiMeshKey* mKeys; C_STRUCT aiMeshKey* mKeys;
#ifdef __cplusplus #ifdef __cplusplus
aiMeshAnim() aiMeshAnim()
: mNumKeys() : mNumKeys()
, mKeys() , mKeys()
{} {}
~aiMeshAnim() ~aiMeshAnim()
{ {
delete[] mKeys; delete[] mKeys;
} }
#endif #endif
}; };
@ -339,63 +339,63 @@ struct aiMeshAnim
* each node affected by the animation a separate series of data is given.*/ * each node affected by the animation a separate series of data is given.*/
struct aiAnimation struct aiAnimation
{ {
/** The name of the animation. If the modeling package this data was /** The name of the animation. If the modeling package this data was
* exported from does support only a single animation channel, this * exported from does support only a single animation channel, this
* name is usually empty (length is zero). */ * name is usually empty (length is zero). */
C_STRUCT aiString mName; C_STRUCT aiString mName;
/** Duration of the animation in ticks. */ /** Duration of the animation in ticks. */
double mDuration; double mDuration;
/** Ticks per second. 0 if not specified in the imported file */ /** Ticks per second. 0 if not specified in the imported file */
double mTicksPerSecond; double mTicksPerSecond;
/** The number of bone animation channels. Each channel affects /** The number of bone animation channels. Each channel affects
* a single node. */ * a single node. */
unsigned int mNumChannels; unsigned int mNumChannels;
/** The node animation channels. Each channel affects a single node. /** The node animation channels. Each channel affects a single node.
* The array is mNumChannels in size. */ * The array is mNumChannels in size. */
C_STRUCT aiNodeAnim** mChannels; C_STRUCT aiNodeAnim** mChannels;
/** The number of mesh animation channels. Each channel affects /** The number of mesh animation channels. Each channel affects
* a single mesh and defines vertex-based animation. */ * a single mesh and defines vertex-based animation. */
unsigned int mNumMeshChannels; unsigned int mNumMeshChannels;
/** The mesh animation channels. Each channel affects a single mesh. /** The mesh animation channels. Each channel affects a single mesh.
* The array is mNumMeshChannels in size. */ * The array is mNumMeshChannels in size. */
C_STRUCT aiMeshAnim** mMeshChannels; C_STRUCT aiMeshAnim** mMeshChannels;
#ifdef __cplusplus #ifdef __cplusplus
aiAnimation() aiAnimation()
: mDuration(-1.) : mDuration(-1.)
, mTicksPerSecond() , mTicksPerSecond()
, mNumChannels() , mNumChannels()
, mChannels() , mChannels()
, mNumMeshChannels() , mNumMeshChannels()
, mMeshChannels() , mMeshChannels()
{ {
} }
~aiAnimation() ~aiAnimation()
{ {
// DO NOT REMOVE THIS ADDITIONAL CHECK // DO NOT REMOVE THIS ADDITIONAL CHECK
if (mNumChannels && mChannels) { if (mNumChannels && mChannels) {
for( unsigned int a = 0; a < mNumChannels; a++) { for( unsigned int a = 0; a < mNumChannels; a++) {
delete mChannels[a]; delete mChannels[a];
} }
delete [] mChannels; delete [] mChannels;
} }
if (mNumMeshChannels && mMeshChannels) { if (mNumMeshChannels && mMeshChannels) {
for( unsigned int a = 0; a < mNumMeshChannels; a++) { for( unsigned int a = 0; a < mNumMeshChannels; a++) {
delete mMeshChannels[a]; delete mMeshChannels[a];
} }
delete [] mMeshChannels; delete [] mMeshChannels;
} }
} }
#endif // __cplusplus #endif // __cplusplus
}; };
@ -414,65 +414,65 @@ namespace Assimp {
template <typename T> template <typename T>
struct Interpolator struct Interpolator
{ {
// ------------------------------------------------------------------ // ------------------------------------------------------------------
/** @brief Get the result of the interpolation between a,b. /** @brief Get the result of the interpolation between a,b.
* *
* The interpolation algorithm depends on the type of the operands. * The interpolation algorithm depends on the type of the operands.
* aiQuaternion's and aiQuatKey's SLERP, the rest does a simple * aiQuaternion's and aiQuatKey's SLERP, the rest does a simple
* linear interpolation. */ * linear interpolation. */
void operator () (T& out,const T& a, const T& b, float d) const { void operator () (T& out,const T& a, const T& b, float d) const {
out = a + (b-a)*d; out = a + (b-a)*d;
} }
}; // ! Interpolator <T> }; // ! Interpolator <T>
//! @cond Never //! @cond Never
template <> template <>
struct Interpolator <aiQuaternion> { struct Interpolator <aiQuaternion> {
void operator () (aiQuaternion& out,const aiQuaternion& a, void operator () (aiQuaternion& out,const aiQuaternion& a,
const aiQuaternion& b, float d) const const aiQuaternion& b, float d) const
{ {
aiQuaternion::Interpolate(out,a,b,d); aiQuaternion::Interpolate(out,a,b,d);
} }
}; // ! Interpolator <aiQuaternion> }; // ! Interpolator <aiQuaternion>
template <> template <>
struct Interpolator <unsigned int> { struct Interpolator <unsigned int> {
void operator () (unsigned int& out,unsigned int a, void operator () (unsigned int& out,unsigned int a,
unsigned int b, float d) const unsigned int b, float d) const
{ {
out = d>0.5f ? b : a; out = d>0.5f ? b : a;
} }
}; // ! Interpolator <aiQuaternion> }; // ! Interpolator <aiQuaternion>
template <> template <>
struct Interpolator <aiVectorKey> { struct Interpolator <aiVectorKey> {
void operator () (aiVector3D& out,const aiVectorKey& a, void operator () (aiVector3D& out,const aiVectorKey& a,
const aiVectorKey& b, float d) const const aiVectorKey& b, float d) const
{ {
Interpolator<aiVector3D> ipl; Interpolator<aiVector3D> ipl;
ipl(out,a.mValue,b.mValue,d); ipl(out,a.mValue,b.mValue,d);
} }
}; // ! Interpolator <aiVectorKey> }; // ! Interpolator <aiVectorKey>
template <> template <>
struct Interpolator <aiQuatKey> { struct Interpolator <aiQuatKey> {
void operator () (aiQuaternion& out, const aiQuatKey& a, void operator () (aiQuaternion& out, const aiQuatKey& a,
const aiQuatKey& b, float d) const const aiQuatKey& b, float d) const
{ {
Interpolator<aiQuaternion> ipl; Interpolator<aiQuaternion> ipl;
ipl(out,a.mValue,b.mValue,d); ipl(out,a.mValue,b.mValue,d);
} }
}; // ! Interpolator <aiQuatKey> }; // ! Interpolator <aiQuatKey>
template <> template <>
struct Interpolator <aiMeshKey> { struct Interpolator <aiMeshKey> {
void operator () (unsigned int& out, const aiMeshKey& a, void operator () (unsigned int& out, const aiMeshKey& a,
const aiMeshKey& b, float d) const const aiMeshKey& b, float d) const
{ {
Interpolator<unsigned int> ipl; Interpolator<unsigned int> ipl;
ipl(out,a.mValue,b.mValue,d); ipl(out,a.mValue,b.mValue,d);
} }
}; // ! Interpolator <aiQuatKey> }; // ! Interpolator <aiQuatKey>
//! @endcond //! @endcond

186
include/assimp/camera.h
View File

@ -97,120 +97,120 @@ extern "C" {
*/ */
struct aiCamera struct aiCamera
{ {
/** The name of the camera. /** The name of the camera.
* *
* There must be a node in the scenegraph with the same name. * There must be a node in the scenegraph with the same name.
* This node specifies the position of the camera in the scene * This node specifies the position of the camera in the scene
* hierarchy and can be animated. * hierarchy and can be animated.
*/ */
C_STRUCT aiString mName; C_STRUCT aiString mName;
/** Position of the camera relative to the coordinate space /** Position of the camera relative to the coordinate space
* defined by the corresponding node. * defined by the corresponding node.
* *
* The default value is 0|0|0. * The default value is 0|0|0.
*/ */
C_STRUCT aiVector3D mPosition; C_STRUCT aiVector3D mPosition;
/** 'Up' - vector of the camera coordinate system relative to /** 'Up' - vector of the camera coordinate system relative to
* the coordinate space defined by the corresponding node. * the coordinate space defined by the corresponding node.
* *
* The 'right' vector of the camera coordinate system is * The 'right' vector of the camera coordinate system is
* the cross product of the up and lookAt vectors. * the cross product of the up and lookAt vectors.
* The default value is 0|1|0. The vector * The default value is 0|1|0. The vector
* may be normalized, but it needn't. * may be normalized, but it needn't.
*/ */
C_STRUCT aiVector3D mUp; C_STRUCT aiVector3D mUp;
/** 'LookAt' - vector of the camera coordinate system relative to /** 'LookAt' - vector of the camera coordinate system relative to
* the coordinate space defined by the corresponding node. * the coordinate space defined by the corresponding node.
* *
* This is the viewing direction of the user. * This is the viewing direction of the user.
* The default value is 0|0|1. The vector * The default value is 0|0|1. The vector
* may be normalized, but it needn't. * may be normalized, but it needn't.
*/ */
C_STRUCT aiVector3D mLookAt; C_STRUCT aiVector3D mLookAt;
/** Half horizontal field of view angle, in radians. /** Half horizontal field of view angle, in radians.
* *
* The field of view angle is the angle between the center * The field of view angle is the angle between the center
* line of the screen and the left or right border. * line of the screen and the left or right border.
* The default value is 1/4PI. * The default value is 1/4PI.
*/ */
float mHorizontalFOV; float mHorizontalFOV;
/** Distance of the near clipping plane from the camera. /** Distance of the near clipping plane from the camera.
* *
* The value may not be 0.f (for arithmetic reasons to prevent * The value may not be 0.f (for arithmetic reasons to prevent
* a division through zero). The default value is 0.1f. * a division through zero). The default value is 0.1f.
*/ */
float mClipPlaneNear; float mClipPlaneNear;
/** Distance of the far clipping plane from the camera. /** Distance of the far clipping plane from the camera.
* *
* The far clipping plane must, of course, be further away than the * The far clipping plane must, of course, be further away than the
* near clipping plane. The default value is 1000.f. The ratio * near clipping plane. The default value is 1000.f. The ratio
* between the near and the far plane should not be too * between the near and the far plane should not be too
* large (between 1000-10000 should be ok) to avoid floating-point * large (between 1000-10000 should be ok) to avoid floating-point
* inaccuracies which could lead to z-fighting. * inaccuracies which could lead to z-fighting.
*/ */
float mClipPlaneFar; float mClipPlaneFar;
/** Screen aspect ratio. /** Screen aspect ratio.
* *
* This is the ration between the width and the height of the * This is the ration between the width and the height of the
* screen. Typical values are 4/3, 1/2 or 1/1. This value is * screen. Typical values are 4/3, 1/2 or 1/1. This value is
* 0 if the aspect ratio is not defined in the source file. * 0 if the aspect ratio is not defined in the source file.
* 0 is also the default value. * 0 is also the default value.
*/ */
float mAspect; float mAspect;
#ifdef __cplusplus #ifdef __cplusplus
aiCamera() aiCamera()
: mUp (0.f,1.f,0.f) : mUp (0.f,1.f,0.f)
, mLookAt (0.f,0.f,1.f) , mLookAt (0.f,0.f,1.f)
, mHorizontalFOV (0.25f * (float)AI_MATH_PI) , mHorizontalFOV (0.25f * (float)AI_MATH_PI)
, mClipPlaneNear (0.1f) , mClipPlaneNear (0.1f)
, mClipPlaneFar (1000.f) , mClipPlaneFar (1000.f)
, mAspect (0.f) , mAspect (0.f)
{} {}
/** @brief Get a *right-handed* camera matrix from me /** @brief Get a *right-handed* camera matrix from me
* @param out Camera matrix to be filled * @param out Camera matrix to be filled
*/ */
void GetCameraMatrix (aiMatrix4x4& out) const void GetCameraMatrix (aiMatrix4x4& out) const
{ {
/** todo: test ... should work, but i'm not absolutely sure */ /** todo: test ... should work, but i'm not absolutely sure */
/** We don't know whether these vectors are already normalized ...*/ /** We don't know whether these vectors are already normalized ...*/
aiVector3D zaxis = mLookAt; zaxis.Normalize(); aiVector3D zaxis = mLookAt; zaxis.Normalize();
aiVector3D yaxis = mUp; yaxis.Normalize(); aiVector3D yaxis = mUp; yaxis.Normalize();
aiVector3D xaxis = mUp^mLookAt; xaxis.Normalize(); aiVector3D xaxis = mUp^mLookAt; xaxis.Normalize();
out.a4 = -(xaxis * mPosition); out.a4 = -(xaxis * mPosition);
out.b4 = -(yaxis * mPosition); out.b4 = -(yaxis * mPosition);
out.c4 = -(zaxis * mPosition); out.c4 = -(zaxis * mPosition);
out.a1 = xaxis.x; out.a1 = xaxis.x;
out.a2 = xaxis.y; out.a2 = xaxis.y;
out.a3 = xaxis.z; out.a3 = xaxis.z;
out.b1 = yaxis.x; out.b1 = yaxis.x;
out.b2 = yaxis.y; out.b2 = yaxis.y;
out.b3 = yaxis.z; out.b3 = yaxis.z;
out.c1 = zaxis.x; out.c1 = zaxis.x;
out.c2 = zaxis.y; out.c2 = zaxis.y;
out.c3 = zaxis.z; out.c3 = zaxis.z;
out.d1 = out.d2 = out.d3 = 0.f; out.d1 = out.d2 = out.d3 = 0.f;
out.d4 = 1.f; out.d4 = 1.f;
} }
#endif #endif
}; };

80
include/assimp/cexport.h
View File

@ -63,17 +63,17 @@ struct aiFileIO; // aiFileIO.h
*/ */
struct aiExportFormatDesc struct aiExportFormatDesc
{ {
/// a short string ID to uniquely identify the export format. Use this ID string to /// a short string ID to uniquely identify the export format. Use this ID string to
/// specify which file format you want to export to when calling #aiExportScene(). /// specify which file format you want to export to when calling #aiExportScene().
/// Example: "dae" or "obj" /// Example: "dae" or "obj"
const char* id; const char* id;
/// A short description of the file format to present to users. Useful if you want /// A short description of the file format to present to users. Useful if you want
/// to allow the user to select an export format. /// to allow the user to select an export format.
const char* description; const char* description;
/// Recommended file extension for the exported file in lower case. /// Recommended file extension for the exported file in lower case.
const char* fileExtension; const char* fileExtension;
}; };
@ -104,7 +104,7 @@ ASSIMP_API const C_STRUCT aiExportFormatDesc* aiGetExportFormatDescription( size
* delete it again. * delete it again.
*/ */
ASSIMP_API void aiCopyScene(const C_STRUCT aiScene* pIn, ASSIMP_API void aiCopyScene(const C_STRUCT aiScene* pIn,
C_STRUCT aiScene** pOut); C_STRUCT aiScene** pOut);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
@ -151,9 +151,9 @@ ASSIMP_API void aiFreeScene(const C_STRUCT aiScene* pIn);
* imported scene. * imported scene.
*/ */
ASSIMP_API aiReturn aiExportScene( const C_STRUCT aiScene* pScene, ASSIMP_API aiReturn aiExportScene( const C_STRUCT aiScene* pScene,
const char* pFormatId, const char* pFormatId,
const char* pFileName, const char* pFileName,
unsigned int pPreprocessing); unsigned int pPreprocessing);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
@ -172,10 +172,10 @@ ASSIMP_API aiReturn aiExportScene( const C_STRUCT aiScene* pScene,
* imported scene. * imported scene.
*/ */
ASSIMP_API aiReturn aiExportSceneEx( const C_STRUCT aiScene* pScene, ASSIMP_API aiReturn aiExportSceneEx( const C_STRUCT aiScene* pScene,
const char* pFormatId, const char* pFormatId,
const char* pFileName, const char* pFileName,
C_STRUCT aiFileIO* pIO, C_STRUCT aiFileIO* pIO,
unsigned int pPreprocessing ); unsigned int pPreprocessing );
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
@ -190,39 +190,39 @@ ASSIMP_API aiReturn aiExportSceneEx( const C_STRUCT aiScene* pScene,
*/ */
struct aiExportDataBlob struct aiExportDataBlob
{ {
/// Size of the data in bytes /// Size of the data in bytes
size_t size; size_t size;
/// The data. /// The data.
void* data; void* data;
/** Name of the blob. An empty string always /** Name of the blob. An empty string always
indicates the first (and primary) blob, indicates the first (and primary) blob,
which contains the actual file data. which contains the actual file data.
Any other blobs are auxiliary files produced Any other blobs are auxiliary files produced
by exporters (i.e. material files). Existence by exporters (i.e. material files). Existence
of such files depends on the file format. Most of such files depends on the file format. Most
formats don't split assets across multiple files. formats don't split assets across multiple files.
If used, blob names usually contain the file If used, blob names usually contain the file
extension that should be used when writing extension that should be used when writing
the data to disc. the data to disc.
*/ */
C_STRUCT aiString name; C_STRUCT aiString name;
/** Pointer to the next blob in the chain or NULL if there is none. */ /** Pointer to the next blob in the chain or NULL if there is none. */
C_STRUCT aiExportDataBlob * next; C_STRUCT aiExportDataBlob * next;
#ifdef __cplusplus #ifdef __cplusplus
/// Default constructor /// Default constructor
aiExportDataBlob() { size = 0; data = next = NULL; } aiExportDataBlob() { size = 0; data = next = NULL; }
/// Releases the data /// Releases the data
~aiExportDataBlob() { delete [] static_cast<unsigned char*>( data ); delete next; } ~aiExportDataBlob() { delete [] static_cast<unsigned char*>( data ); delete next; }
private: private:
// no copying // no copying
aiExportDataBlob(const aiExportDataBlob& ); aiExportDataBlob(const aiExportDataBlob& );
aiExportDataBlob& operator= (const aiExportDataBlob& ); aiExportDataBlob& operator= (const aiExportDataBlob& );
#endif // __cplusplus #endif // __cplusplus
}; };

60
include/assimp/cfileio.h
View File

@ -75,16 +75,16 @@ typedef char* aiUserData;
* or memory locations. */ * or memory locations. */
struct aiFileIO struct aiFileIO
{ {
/** Function used to open a new file /** Function used to open a new file
*/ */
aiFileOpenProc OpenProc; aiFileOpenProc OpenProc;
/** Function used to close an existing file /** Function used to close an existing file
*/ */
aiFileCloseProc CloseProc; aiFileCloseProc CloseProc;
/** User-defined, opaque data */ /** User-defined, opaque data */
aiUserData UserData; aiUserData UserData;
}; };
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
@ -99,34 +99,34 @@ struct aiFileIO
* such as ZIP archives or memory locations. */ * such as ZIP archives or memory locations. */
struct aiFile struct aiFile
{ {
/** Callback to read from a file */ /** Callback to read from a file */
aiFileReadProc ReadProc; aiFileReadProc ReadProc;
/** Callback to write to a file */ /** Callback to write to a file */
aiFileWriteProc WriteProc; aiFileWriteProc WriteProc;
/** Callback to retrieve the current position of /** Callback to retrieve the current position of
* the file cursor (ftell()) * the file cursor (ftell())
*/ */
aiFileTellProc TellProc; aiFileTellProc TellProc;
/** Callback to retrieve the size of the file, /** Callback to retrieve the size of the file,
* in bytes * in bytes
*/ */
aiFileTellProc FileSizeProc; aiFileTellProc FileSizeProc;
/** Callback to set the current position /** Callback to set the current position
* of the file cursor (fseek()) * of the file cursor (fseek())
*/ */
aiFileSeek SeekProc; aiFileSeek SeekProc;
/** Callback to flush the file contents /** Callback to flush the file contents
*/ */
aiFileFlushProc FlushProc; aiFileFlushProc FlushProc;
/** User-defined, opaque data /** User-defined, opaque data
*/ */
aiUserData UserData; aiUserData UserData;
}; };
#ifdef __cplusplus #ifdef __cplusplus

126
include/assimp/cimport.h
View File

@ -64,11 +64,11 @@ typedef void (*aiLogStreamCallback)(const char* /* message */, char* /* user */)
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
struct aiLogStream struct aiLogStream
{ {
/** callback to be called */ /** callback to be called */
aiLogStreamCallback callback; aiLogStreamCallback callback;
/** user data to be passed to the callback */ /** user data to be passed to the callback */
char* user; char* user;
}; };
@ -108,8 +108,8 @@ typedef int aiBool;
* @return Pointer to the imported data or NULL if the import failed. * @return Pointer to the imported data or NULL if the import failed.
*/ */
ASSIMP_API const C_STRUCT aiScene* aiImportFile( ASSIMP_API const C_STRUCT aiScene* aiImportFile(
const char* pFile, const char* pFile,
unsigned int pFlags); unsigned int pFlags);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Reads the given file using user-defined I/O functions and returns /** Reads the given file using user-defined I/O functions and returns
@ -133,9 +133,9 @@ ASSIMP_API const C_STRUCT aiScene* aiImportFile(
* @note Include <aiFileIO.h> for the definition of #aiFileIO. * @note Include <aiFileIO.h> for the definition of #aiFileIO.
*/ */
ASSIMP_API const C_STRUCT aiScene* aiImportFileEx( ASSIMP_API const C_STRUCT aiScene* aiImportFileEx(
const char* pFile, const char* pFile,
unsigned int pFlags, unsigned int pFlags,
C_STRUCT aiFileIO* pFS); C_STRUCT aiFileIO* pFS);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Same as #aiImportFileEx, but adds an extra parameter containing importer settings. /** Same as #aiImportFileEx, but adds an extra parameter containing importer settings.
@ -154,10 +154,10 @@ ASSIMP_API const C_STRUCT aiScene* aiImportFileEx(
* @see aiImportFileEx * @see aiImportFileEx
*/ */
ASSIMP_API const C_STRUCT aiScene* aiImportFileExWithProperties( ASSIMP_API const C_STRUCT aiScene* aiImportFileExWithProperties(
const char* pFile, const char* pFile,
unsigned int pFlags, unsigned int pFlags,
C_STRUCT aiFileIO* pFS, C_STRUCT aiFileIO* pFS,
const C_STRUCT aiPropertyStore* pProps); const C_STRUCT aiPropertyStore* pProps);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Reads the given file from a given memory buffer, /** Reads the given file from a given memory buffer,
@ -191,10 +191,10 @@ ASSIMP_API const C_STRUCT aiScene* aiImportFileExWithProperties(
* the regular aiImportFileEx()/aiImportFileExWithProperties() API. * the regular aiImportFileEx()/aiImportFileExWithProperties() API.
*/ */
ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemory( ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemory(
const char* pBuffer, const char* pBuffer,
unsigned int pLength, unsigned int pLength,
unsigned int pFlags, unsigned int pFlags,
const char* pHint); const char* pHint);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Same as #aiImportFileFromMemory, but adds an extra parameter containing importer settings. /** Same as #aiImportFileFromMemory, but adds an extra parameter containing importer settings.
@ -225,11 +225,11 @@ ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemory(
* @see aiImportFileFromMemory * @see aiImportFileFromMemory
*/ */
ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemoryWithProperties( ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemoryWithProperties(
const char* pBuffer, const char* pBuffer,
unsigned int pLength, unsigned int pLength,
unsigned int pFlags, unsigned int pFlags,
const char* pHint, const char* pHint,
const C_STRUCT aiPropertyStore* pProps); const C_STRUCT aiPropertyStore* pProps);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Apply post-processing to an already-imported scene. /** Apply post-processing to an already-imported scene.
@ -247,8 +247,8 @@ ASSIMP_API const C_STRUCT aiScene* aiImportFileFromMemoryWithProperties(
* which can actually cause the scene to be reset to NULL. * which can actually cause the scene to be reset to NULL.
*/ */
ASSIMP_API const C_STRUCT aiScene* aiApplyPostProcessing( ASSIMP_API const C_STRUCT aiScene* aiApplyPostProcessing(
const C_STRUCT aiScene* pScene, const C_STRUCT aiScene* pScene,
unsigned int pFlags); unsigned int pFlags);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Get one of the predefine log streams. This is the quick'n'easy solution to /** Get one of the predefine log streams. This is the quick'n'easy solution to
@ -271,8 +271,8 @@ ASSIMP_API const C_STRUCT aiScene* aiApplyPostProcessing(
* @return The log stream. callback is set to NULL if something went wrong. * @return The log stream. callback is set to NULL if something went wrong.
*/ */
ASSIMP_API C_STRUCT aiLogStream aiGetPredefinedLogStream( ASSIMP_API C_STRUCT aiLogStream aiGetPredefinedLogStream(
C_ENUM aiDefaultLogStream pStreams, C_ENUM aiDefaultLogStream pStreams,
const char* file); const char* file);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Attach a custom log stream to the libraries' logging system. /** Attach a custom log stream to the libraries' logging system.
@ -285,7 +285,7 @@ ASSIMP_API C_STRUCT aiLogStream aiGetPredefinedLogStream(
* Alternatively (for the lazy folks) #aiDetachAllLogStreams is provided. * Alternatively (for the lazy folks) #aiDetachAllLogStreams is provided.
*/ */
ASSIMP_API void aiAttachLogStream( ASSIMP_API void aiAttachLogStream(
const C_STRUCT aiLogStream* stream); const C_STRUCT aiLogStream* stream);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Enable verbose logging. Verbose logging includes debug-related stuff and /** Enable verbose logging. Verbose logging includes debug-related stuff and
@ -306,7 +306,7 @@ ASSIMP_API void aiEnableVerboseLogging(aiBool d);
* @see aiDetachAllLogStreams * @see aiDetachAllLogStreams
*/ */
ASSIMP_API C_ENUM aiReturn aiDetachLogStream( ASSIMP_API C_ENUM aiReturn aiDetachLogStream(
const C_STRUCT aiLogStream* stream); const C_STRUCT aiLogStream* stream);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Detach all active log streams from the libraries' logging system. /** Detach all active log streams from the libraries' logging system.
@ -325,7 +325,7 @@ ASSIMP_API void aiDetachAllLogStreams(void);
* @param pScene The imported data to release. NULL is a valid value. * @param pScene The imported data to release. NULL is a valid value.
*/ */
ASSIMP_API void aiReleaseImport( ASSIMP_API void aiReleaseImport(
const C_STRUCT aiScene* pScene); const C_STRUCT aiScene* pScene);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Returns the error text of the last failed import process. /** Returns the error text of the last failed import process.
@ -344,7 +344,7 @@ ASSIMP_API const char* aiGetErrorString();
* @return AI_TRUE if the file extension is supported. * @return AI_TRUE if the file extension is supported.
*/ */
ASSIMP_API aiBool aiIsExtensionSupported( ASSIMP_API aiBool aiIsExtensionSupported(
const char* szExtension); const char* szExtension);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Get a list of all file extensions supported by ASSIMP. /** Get a list of all file extensions supported by ASSIMP.
@ -355,7 +355,7 @@ ASSIMP_API aiBool aiIsExtensionSupported(
* Format of the list: "*.3ds;*.obj;*.dae". NULL is not a valid parameter. * Format of the list: "*.3ds;*.obj;*.dae". NULL is not a valid parameter.
*/ */
ASSIMP_API void aiGetExtensionList( ASSIMP_API void aiGetExtensionList(
C_STRUCT aiString* szOut); C_STRUCT aiString* szOut);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Get the approximated storage required by an imported asset /** Get the approximated storage required by an imported asset
@ -363,8 +363,8 @@ ASSIMP_API void aiGetExtensionList(
* @param in Data structure to be filled. * @param in Data structure to be filled.
*/ */
ASSIMP_API void aiGetMemoryRequirements( ASSIMP_API void aiGetMemoryRequirements(
const C_STRUCT aiScene* pIn, const C_STRUCT aiScene* pIn,
C_STRUCT aiMemoryInfo* in); C_STRUCT aiMemoryInfo* in);
@ -395,9 +395,9 @@ ASSIMP_API void aiReleasePropertyStore(C_STRUCT aiPropertyStore* p);
* @param value New value for the property * @param value New value for the property
*/ */
ASSIMP_API void aiSetImportPropertyInteger( ASSIMP_API void aiSetImportPropertyInteger(
C_STRUCT aiPropertyStore* store, C_STRUCT aiPropertyStore* store,
const char* szName, const char* szName,
int value); int value);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Set a floating-point property. /** Set a floating-point property.
@ -412,9 +412,9 @@ ASSIMP_API void aiSetImportPropertyInteger(
* @param value New value for the property * @param value New value for the property
*/ */
ASSIMP_API void aiSetImportPropertyFloat( ASSIMP_API void aiSetImportPropertyFloat(
C_STRUCT aiPropertyStore* store, C_STRUCT aiPropertyStore* store,
const char* szName, const char* szName,
float value); float value);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Set a string property. /** Set a string property.
@ -429,9 +429,9 @@ ASSIMP_API void aiSetImportPropertyFloat(
* @param st New value for the property * @param st New value for the property
*/ */
ASSIMP_API void aiSetImportPropertyString( ASSIMP_API void aiSetImportPropertyString(
C_STRUCT aiPropertyStore* store, C_STRUCT aiPropertyStore* store,
const char* szName, const char* szName,
const C_STRUCT aiString* st); const C_STRUCT aiString* st);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Set a matrix property. /** Set a matrix property.
@ -446,9 +446,9 @@ ASSIMP_API void aiSetImportPropertyString(
* @param mat New value for the property * @param mat New value for the property
*/ */
ASSIMP_API void aiSetImportPropertyMatrix( ASSIMP_API void aiSetImportPropertyMatrix(
C_STRUCT aiPropertyStore* store, C_STRUCT aiPropertyStore* store,
const char* szName, const char* szName,
const C_STRUCT aiMatrix4x4* mat); const C_STRUCT aiMatrix4x4* mat);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Construct a quaternion from a 3x3 rotation matrix. /** Construct a quaternion from a 3x3 rotation matrix.
@ -457,8 +457,8 @@ ASSIMP_API void aiSetImportPropertyMatrix(
* @see aiQuaternion(const aiMatrix3x3& pRotMatrix) * @see aiQuaternion(const aiMatrix3x3& pRotMatrix)
*/ */
ASSIMP_API void aiCreateQuaternionFromMatrix( ASSIMP_API void aiCreateQuaternionFromMatrix(
C_STRUCT aiQuaternion* quat, C_STRUCT aiQuaternion* quat,
const C_STRUCT aiMatrix3x3* mat); const C_STRUCT aiMatrix3x3* mat);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Decompose a transformation matrix into its rotational, translational and /** Decompose a transformation matrix into its rotational, translational and
@ -471,24 +471,24 @@ ASSIMP_API void aiCreateQuaternionFromMatrix(
* @see aiMatrix4x4::Decompose (aiVector3D&, aiQuaternion&, aiVector3D&) const; * @see aiMatrix4x4::Decompose (aiVector3D&, aiQuaternion&, aiVector3D&) const;
*/ */
ASSIMP_API void aiDecomposeMatrix( ASSIMP_API void aiDecomposeMatrix(
const C_STRUCT aiMatrix4x4* mat, const C_STRUCT aiMatrix4x4* mat,
C_STRUCT aiVector3D* scaling, C_STRUCT aiVector3D* scaling,
C_STRUCT aiQuaternion* rotation, C_STRUCT aiQuaternion* rotation,
C_STRUCT aiVector3D* position); C_STRUCT aiVector3D* position);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Transpose a 4x4 matrix. /** Transpose a 4x4 matrix.
* @param mat Pointer to the matrix to be transposed * @param mat Pointer to the matrix to be transposed
*/ */
ASSIMP_API void aiTransposeMatrix4( ASSIMP_API void aiTransposeMatrix4(
C_STRUCT aiMatrix4x4* mat); C_STRUCT aiMatrix4x4* mat);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Transpose a 3x3 matrix. /** Transpose a 3x3 matrix.
* @param mat Pointer to the matrix to be transposed * @param mat Pointer to the matrix to be transposed
*/ */
ASSIMP_API void aiTransposeMatrix3( ASSIMP_API void aiTransposeMatrix3(
C_STRUCT aiMatrix3x3* mat); C_STRUCT aiMatrix3x3* mat);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Transform a vector by a 3x3 matrix /** Transform a vector by a 3x3 matrix
@ -496,8 +496,8 @@ ASSIMP_API void aiTransposeMatrix3(
* @param mat Matrix to transform the vector with. * @param mat Matrix to transform the vector with.
*/ */
ASSIMP_API void aiTransformVecByMatrix3( ASSIMP_API void aiTransformVecByMatrix3(
C_STRUCT aiVector3D* vec, C_STRUCT aiVector3D* vec,
const C_STRUCT aiMatrix3x3* mat); const C_STRUCT aiMatrix3x3* mat);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Transform a vector by a 4x4 matrix /** Transform a vector by a 4x4 matrix
@ -505,8 +505,8 @@ ASSIMP_API void aiTransformVecByMatrix3(
* @param mat Matrix to transform the vector with. * @param mat Matrix to transform the vector with.
*/ */
ASSIMP_API void aiTransformVecByMatrix4( ASSIMP_API void aiTransformVecByMatrix4(
C_STRUCT aiVector3D* vec, C_STRUCT aiVector3D* vec,
const C_STRUCT aiMatrix4x4* mat); const C_STRUCT aiMatrix4x4* mat);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Multiply two 4x4 matrices. /** Multiply two 4x4 matrices.
@ -514,8 +514,8 @@ ASSIMP_API void aiTransformVecByMatrix4(
* @param src Matrix to be multiplied with 'dst'. * @param src Matrix to be multiplied with 'dst'.
*/ */
ASSIMP_API void aiMultiplyMatrix4( ASSIMP_API void aiMultiplyMatrix4(
C_STRUCT aiMatrix4x4* dst, C_STRUCT aiMatrix4x4* dst,
const C_STRUCT aiMatrix4x4* src); const C_STRUCT aiMatrix4x4* src);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Multiply two 3x3 matrices. /** Multiply two 3x3 matrices.
@ -523,22 +523,22 @@ ASSIMP_API void aiMultiplyMatrix4(
* @param src Matrix to be multiplied with 'dst'. * @param src Matrix to be multiplied with 'dst'.
*/ */
ASSIMP_API void aiMultiplyMatrix3( ASSIMP_API void aiMultiplyMatrix3(
C_STRUCT aiMatrix3x3* dst, C_STRUCT aiMatrix3x3* dst,
const C_STRUCT aiMatrix3x3* src); const C_STRUCT aiMatrix3x3* src);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Get a 3x3 identity matrix. /** Get a 3x3 identity matrix.
* @param mat Matrix to receive its personal identity * @param mat Matrix to receive its personal identity
*/ */
ASSIMP_API void aiIdentityMatrix3( ASSIMP_API void aiIdentityMatrix3(
C_STRUCT aiMatrix3x3* mat); C_STRUCT aiMatrix3x3* mat);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Get a 4x4 identity matrix. /** Get a 4x4 identity matrix.
* @param mat Matrix to receive its personal identity * @param mat Matrix to receive its personal identity
*/ */
ASSIMP_API void aiIdentityMatrix4( ASSIMP_API void aiIdentityMatrix4(
C_STRUCT aiMatrix4x4* mat); C_STRUCT aiMatrix4x4* mat);
// -------------------------------------------------------------------------------- // --------------------------------------------------------------------------------
/** Returns the number of import file formats available in the current Assimp build. /** Returns the number of import file formats available in the current Assimp build.

46
include/assimp/color4.h
View File

@ -56,37 +56,37 @@ template <typename TReal>
class aiColor4t class aiColor4t
{ {
public: public:
aiColor4t () : r(), g(), b(), a() {} aiColor4t () : r(), g(), b(), a() {}
aiColor4t (TReal _r, TReal _g, TReal _b, TReal _a) aiColor4t (TReal _r, TReal _g, TReal _b, TReal _a)
: r(_r), g(_g), b(_b), a(_a) {} : r(_r), g(_g), b(_b), a(_a) {}
aiColor4t (TReal _r) : r(_r), g(_r), b(_r), a(_r) {} aiColor4t (TReal _r) : r(_r), g(_r), b(_r), a(_r) {}
aiColor4t (const aiColor4t& o) aiColor4t (const aiColor4t& o)
: r(o.r), g(o.g), b(o.b), a(o.a) {} : r(o.r), g(o.g), b(o.b), a(o.a) {}
public: public:
// combined operators // combined operators
const aiColor4t& operator += (const aiColor4t& o); const aiColor4t& operator += (const aiColor4t& o);
const aiColor4t& operator -= (const aiColor4t& o); const aiColor4t& operator -= (const aiColor4t& o);
const aiColor4t& operator *= (TReal f); const aiColor4t& operator *= (TReal f);
const aiColor4t& operator /= (TReal f); const aiColor4t& operator /= (TReal f);
public: public:
// comparison // comparison
bool operator == (const aiColor4t& other) const; bool operator == (const aiColor4t& other) const;
bool operator != (const aiColor4t& other) const; bool operator != (const aiColor4t& other) const;
bool operator < (const aiColor4t& other) const; bool operator < (const aiColor4t& other) const;
// color tuple access, rgba order // color tuple access, rgba order
inline TReal operator[](unsigned int i) const; inline TReal operator[](unsigned int i) const;
inline TReal& operator[](unsigned int i); inline TReal& operator[](unsigned int i);
/** check whether a color is (close to) black */ /** check whether a color is (close to) black */
inline bool IsBlack() const; inline bool IsBlack() const;
public: public:
// Red, green, blue and alpha color values // Red, green, blue and alpha color values
TReal r, g, b, a; TReal r, g, b, a;
} PACK_STRUCT; // !struct aiColor4D } PACK_STRUCT; // !struct aiColor4D
typedef aiColor4t<float> aiColor4D; typedef aiColor4t<float> aiColor4D;
@ -94,7 +94,7 @@ typedef aiColor4t<float> aiColor4D;
#else #else
struct aiColor4D { struct aiColor4D {
float r, g, b, a; float r, g, b, a;
} PACK_STRUCT; } PACK_STRUCT;
#endif // __cplusplus #endif // __cplusplus

106
include/assimp/color4.inl
View File

@ -51,131 +51,131 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator += (const aiColor4t<TReal>& o) { AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator += (const aiColor4t<TReal>& o) {
r += o.r; g += o.g; b += o.b; a += o.a; r += o.r; g += o.g; b += o.b; a += o.a;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator -= (const aiColor4t<TReal>& o) { AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator -= (const aiColor4t<TReal>& o) {
r -= o.r; g -= o.g; b -= o.b; a -= o.a; r -= o.r; g -= o.g; b -= o.b; a -= o.a;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator *= (TReal f) { AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator *= (TReal f) {
r *= f; g *= f; b *= f; a *= f; r *= f; g *= f; b *= f; a *= f;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator /= (TReal f) { AI_FORCE_INLINE const aiColor4t<TReal>& aiColor4t<TReal>::operator /= (TReal f) {
r /= f; g /= f; b /= f; a /= f; r /= f; g /= f; b /= f; a /= f;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE TReal aiColor4t<TReal>::operator[](unsigned int i) const { AI_FORCE_INLINE TReal aiColor4t<TReal>::operator[](unsigned int i) const {
return *(&r + i); return *(&r + i);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE TReal& aiColor4t<TReal>::operator[](unsigned int i) { AI_FORCE_INLINE TReal& aiColor4t<TReal>::operator[](unsigned int i) {
return *(&r + i); return *(&r + i);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE bool aiColor4t<TReal>::operator== (const aiColor4t<TReal>& other) const { AI_FORCE_INLINE bool aiColor4t<TReal>::operator== (const aiColor4t<TReal>& other) const {
return r == other.r && g == other.g && b == other.b && a == other.a; return r == other.r && g == other.g && b == other.b && a == other.a;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE bool aiColor4t<TReal>::operator!= (const aiColor4t<TReal>& other) const { AI_FORCE_INLINE bool aiColor4t<TReal>::operator!= (const aiColor4t<TReal>& other) const {
return r != other.r || g != other.g || b != other.b || a != other.a; return r != other.r || g != other.g || b != other.b || a != other.a;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE bool aiColor4t<TReal>::operator< (const aiColor4t<TReal>& other) const { AI_FORCE_INLINE bool aiColor4t<TReal>::operator< (const aiColor4t<TReal>& other) const {
return r < other.r || ( return r < other.r || (
r == other.r && ( r == other.r && (
g < other.g || ( g < other.g || (
g == other.g && ( g == other.g && (
b < other.b || ( b < other.b || (
b == other.b && ( b == other.b && (
a < other.a a < other.a
) )
) )
) )
) )
) )
); );
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator + (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2) { AI_FORCE_INLINE aiColor4t<TReal> operator + (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2) {
return aiColor4t<TReal>( v1.r + v2.r, v1.g + v2.g, v1.b + v2.b, v1.a + v2.a); return aiColor4t<TReal>( v1.r + v2.r, v1.g + v2.g, v1.b + v2.b, v1.a + v2.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator - (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2) { AI_FORCE_INLINE aiColor4t<TReal> operator - (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2) {
return aiColor4t<TReal>( v1.r - v2.r, v1.g - v2.g, v1.b - v2.b, v1.a - v2.a); return aiColor4t<TReal>( v1.r - v2.r, v1.g - v2.g, v1.b - v2.b, v1.a - v2.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator * (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2) { AI_FORCE_INLINE aiColor4t<TReal> operator * (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2) {
return aiColor4t<TReal>( v1.r * v2.r, v1.g * v2.g, v1.b * v2.b, v1.a * v2.a); return aiColor4t<TReal>( v1.r * v2.r, v1.g * v2.g, v1.b * v2.b, v1.a * v2.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator / (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2) { AI_FORCE_INLINE aiColor4t<TReal> operator / (const aiColor4t<TReal>& v1, const aiColor4t<TReal>& v2) {
return aiColor4t<TReal>( v1.r / v2.r, v1.g / v2.g, v1.b / v2.b, v1.a / v2.a); return aiColor4t<TReal>( v1.r / v2.r, v1.g / v2.g, v1.b / v2.b, v1.a / v2.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator * ( TReal f, const aiColor4t<TReal>& v) { AI_FORCE_INLINE aiColor4t<TReal> operator * ( TReal f, const aiColor4t<TReal>& v) {
return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a); return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator * ( const aiColor4t<TReal>& v, TReal f) { AI_FORCE_INLINE aiColor4t<TReal> operator * ( const aiColor4t<TReal>& v, TReal f) {
return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a); return aiColor4t<TReal>( f*v.r, f*v.g, f*v.b, f*v.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator / ( const aiColor4t<TReal>& v, TReal f) { AI_FORCE_INLINE aiColor4t<TReal> operator / ( const aiColor4t<TReal>& v, TReal f) {
return v * (1/f); return v * (1/f);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator / ( TReal f,const aiColor4t<TReal>& v) { AI_FORCE_INLINE aiColor4t<TReal> operator / ( TReal f,const aiColor4t<TReal>& v) {
return aiColor4t<TReal>(f,f,f,f)/v; return aiColor4t<TReal>(f,f,f,f)/v;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator + ( const aiColor4t<TReal>& v, TReal f) { AI_FORCE_INLINE aiColor4t<TReal> operator + ( const aiColor4t<TReal>& v, TReal f) {
return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a); return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator - ( const aiColor4t<TReal>& v, TReal f) { AI_FORCE_INLINE aiColor4t<TReal> operator - ( const aiColor4t<TReal>& v, TReal f) {
return aiColor4t<TReal>( v.r-f, v.g-f, v.b-f, v.a-f); return aiColor4t<TReal>( v.r-f, v.g-f, v.b-f, v.a-f);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator + ( TReal f, const aiColor4t<TReal>& v) { AI_FORCE_INLINE aiColor4t<TReal> operator + ( TReal f, const aiColor4t<TReal>& v) {
return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a); return aiColor4t<TReal>( f+v.r, f+v.g, f+v.b, f+v.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiColor4t<TReal> operator - ( TReal f, const aiColor4t<TReal>& v) { AI_FORCE_INLINE aiColor4t<TReal> operator - ( TReal f, const aiColor4t<TReal>& v) {
return aiColor4t<TReal>( f-v.r, f-v.g, f-v.b, f-v.a); return aiColor4t<TReal>( f-v.r, f-v.g, f-v.b, f-v.a);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline bool aiColor4t<TReal> :: IsBlack() const { inline bool aiColor4t<TReal> :: IsBlack() const {
// The alpha component doesn't care here. black is black. // The alpha component doesn't care here. black is black.
static const TReal epsilon = 10e-3f; static const TReal epsilon = 10e-3f;
return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon; return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon;
} }
#endif // __cplusplus #endif // __cplusplus

248
include/assimp/config.h
View File

@ -75,7 +75,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* Property type: bool. Default value: false. * Property type: bool. Default value: false.
*/ */
#define AI_CONFIG_GLOB_MEASURE_TIME \ #define AI_CONFIG_GLOB_MEASURE_TIME \
"GLOB_MEASURE_TIME" "GLOB_MEASURE_TIME"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -87,7 +87,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
#define AI_CONFIG_IMPORT_NO_SKELETON_MESHES \ #define AI_CONFIG_IMPORT_NO_SKELETON_MESHES \
"IMPORT_NO_SKELETON_MESHES" "IMPORT_NO_SKELETON_MESHES"
@ -108,7 +108,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* Property type: int, default value: -1. * Property type: int, default value: -1.
*/ */
#define AI_CONFIG_GLOB_MULTITHREADING \ #define AI_CONFIG_GLOB_MULTITHREADING \
"GLOB_MULTITHREADING" "GLOB_MULTITHREADING"
#endif #endif
// ########################################################################### // ###########################################################################
@ -127,12 +127,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
#define AI_CONFIG_PP_SBBC_MAX_BONES \ #define AI_CONFIG_PP_SBBC_MAX_BONES \
"PP_SBBC_MAX_BONES" "PP_SBBC_MAX_BONES"
// default limit for bone count // default limit for bone count
#if (!defined AI_SBBC_DEFAULT_MAX_BONES) #if (!defined AI_SBBC_DEFAULT_MAX_BONES)
# define AI_SBBC_DEFAULT_MAX_BONES 60 # define AI_SBBC_DEFAULT_MAX_BONES 60
#endif #endif
@ -145,7 +145,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* Property type: float. Default value: 45 degrees * Property type: float. Default value: 45 degrees
*/ */
#define AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE \ #define AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE \
"PP_CT_MAX_SMOOTHING_ANGLE" "PP_CT_MAX_SMOOTHING_ANGLE"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Source UV channel for tangent space computation. /** @brief Source UV channel for tangent space computation.
@ -155,7 +155,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
#define AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX \ #define AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX \
"PP_CT_TEXTURE_CHANNEL_INDEX" "PP_CT_TEXTURE_CHANNEL_INDEX"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Specifies the maximum angle that may be between two face normals /** @brief Specifies the maximum angle that may be between two face normals
@ -170,7 +170,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* the output quality may be reduced. * the output quality may be reduced.
*/ */
#define AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE \ #define AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE \
"PP_GSN_MAX_SMOOTHING_ANGLE" "PP_GSN_MAX_SMOOTHING_ANGLE"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -183,8 +183,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* a default palette (from Quake 1) is used. * a default palette (from Quake 1) is used.
* Property type: string. * Property type: string.
*/ */
#define AI_CONFIG_IMPORT_MDL_COLORMAP \ #define AI_CONFIG_IMPORT_MDL_COLORMAP \
"IMPORT_MDL_COLORMAP" "IMPORT_MDL_COLORMAP"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Configures the #aiProcess_RemoveRedundantMaterials step to /** @brief Configures the #aiProcess_RemoveRedundantMaterials step to
@ -205,8 +205,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* @note Linefeeds, tabs or carriage returns are treated as whitespace. * @note Linefeeds, tabs or carriage returns are treated as whitespace.
* Material names are case sensitive. * Material names are case sensitive.
*/ */
#define AI_CONFIG_PP_RRM_EXCLUDE_LIST \ #define AI_CONFIG_PP_RRM_EXCLUDE_LIST \
"PP_RRM_EXCLUDE_LIST" "PP_RRM_EXCLUDE_LIST"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Configures the #aiProcess_PreTransformVertices step to /** @brief Configures the #aiProcess_PreTransformVertices step to
@ -220,8 +220,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* any transformations. * any transformations.
* Property type: bool. Default value: false. * Property type: bool. Default value: false.
*/ */
#define AI_CONFIG_PP_PTV_KEEP_HIERARCHY \ #define AI_CONFIG_PP_PTV_KEEP_HIERARCHY \
"PP_PTV_KEEP_HIERARCHY" "PP_PTV_KEEP_HIERARCHY"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Configures the #aiProcess_PreTransformVertices step to normalize /** @brief Configures the #aiProcess_PreTransformVertices step to normalize
@ -230,8 +230,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* meshes are scaled appropriately (uniformly of course!). * meshes are scaled appropriately (uniformly of course!).
* This might be useful if you don't know the spatial dimension of the input * This might be useful if you don't know the spatial dimension of the input
* data*/ * data*/
#define AI_CONFIG_PP_PTV_NORMALIZE \ #define AI_CONFIG_PP_PTV_NORMALIZE \
"PP_PTV_NORMALIZE" "PP_PTV_NORMALIZE"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Configures the #aiProcess_PreTransformVertices step to use /** @brief Configures the #aiProcess_PreTransformVertices step to use
@ -239,8 +239,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* transforming vertices. * transforming vertices.
* Property type: bool. Default value: false. * Property type: bool. Default value: false.
*/ */
#define AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION \ #define AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION \
"PP_PTV_ADD_ROOT_TRANSFORMATION" "PP_PTV_ADD_ROOT_TRANSFORMATION"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Configures the #aiProcess_PreTransformVertices step to use /** @brief Configures the #aiProcess_PreTransformVertices step to use
@ -249,8 +249,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* of the transformation matrix. * of the transformation matrix.
* Property type: aiMatrix4x4. * Property type: aiMatrix4x4.
*/ */
#define AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION \ #define AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION \
"PP_PTV_ROOT_TRANSFORMATION" "PP_PTV_ROOT_TRANSFORMATION"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Configures the #aiProcess_FindDegenerates step to /** @brief Configures the #aiProcess_FindDegenerates step to
@ -263,7 +263,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* Property type: bool. Default value: false. * Property type: bool. Default value: false.
*/ */
#define AI_CONFIG_PP_FD_REMOVE \ #define AI_CONFIG_PP_FD_REMOVE \
"PP_FD_REMOVE" "PP_FD_REMOVE"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Configures the #aiProcess_OptimizeGraph step to preserve nodes /** @brief Configures the #aiProcess_OptimizeGraph step to preserve nodes
@ -283,8 +283,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* @note Linefeeds, tabs or carriage returns are treated as whitespace. * @note Linefeeds, tabs or carriage returns are treated as whitespace.
* Node names are case sensitive. * Node names are case sensitive.
*/ */
#define AI_CONFIG_PP_OG_EXCLUDE_LIST \ #define AI_CONFIG_PP_OG_EXCLUDE_LIST \
"PP_OG_EXCLUDE_LIST" "PP_OG_EXCLUDE_LIST"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Set the maximum number of triangles in a mesh. /** @brief Set the maximum number of triangles in a mesh.
@ -294,12 +294,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* @note The default value is AI_SLM_DEFAULT_MAX_TRIANGLES * @note The default value is AI_SLM_DEFAULT_MAX_TRIANGLES
* Property type: integer. * Property type: integer.
*/ */
#define AI_CONFIG_PP_SLM_TRIANGLE_LIMIT \ #define AI_CONFIG_PP_SLM_TRIANGLE_LIMIT \
"PP_SLM_TRIANGLE_LIMIT" "PP_SLM_TRIANGLE_LIMIT"
// default value for AI_CONFIG_PP_SLM_TRIANGLE_LIMIT // default value for AI_CONFIG_PP_SLM_TRIANGLE_LIMIT
#if (!defined AI_SLM_DEFAULT_MAX_TRIANGLES) #if (!defined AI_SLM_DEFAULT_MAX_TRIANGLES)
# define AI_SLM_DEFAULT_MAX_TRIANGLES 1000000 # define AI_SLM_DEFAULT_MAX_TRIANGLES 1000000
#endif #endif
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -311,11 +311,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* Property type: integer. * Property type: integer.
*/ */
#define AI_CONFIG_PP_SLM_VERTEX_LIMIT \ #define AI_CONFIG_PP_SLM_VERTEX_LIMIT \
"PP_SLM_VERTEX_LIMIT" "PP_SLM_VERTEX_LIMIT"
// default value for AI_CONFIG_PP_SLM_VERTEX_LIMIT // default value for AI_CONFIG_PP_SLM_VERTEX_LIMIT
#if (!defined AI_SLM_DEFAULT_MAX_VERTICES) #if (!defined AI_SLM_DEFAULT_MAX_VERTICES)
# define AI_SLM_DEFAULT_MAX_VERTICES 1000000 # define AI_SLM_DEFAULT_MAX_VERTICES 1000000
#endif #endif
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -324,12 +324,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* This is used by the #aiProcess_LimitBoneWeights PostProcess-Step. * This is used by the #aiProcess_LimitBoneWeights PostProcess-Step.
* @note The default value is AI_LBW_MAX_WEIGHTS * @note The default value is AI_LBW_MAX_WEIGHTS
* Property type: integer.*/ * Property type: integer.*/
#define AI_CONFIG_PP_LBW_MAX_WEIGHTS \ #define AI_CONFIG_PP_LBW_MAX_WEIGHTS \
"PP_LBW_MAX_WEIGHTS" "PP_LBW_MAX_WEIGHTS"
// default value for AI_CONFIG_PP_LBW_MAX_WEIGHTS // default value for AI_CONFIG_PP_LBW_MAX_WEIGHTS
#if (!defined AI_LMW_MAX_WEIGHTS) #if (!defined AI_LMW_MAX_WEIGHTS)
# define AI_LMW_MAX_WEIGHTS 0x4 # define AI_LMW_MAX_WEIGHTS 0x4
#endif // !! AI_LMW_MAX_WEIGHTS #endif // !! AI_LMW_MAX_WEIGHTS
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -339,11 +339,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* @note The default value is AI_DEBONE_THRESHOLD * @note The default value is AI_DEBONE_THRESHOLD
* Property type: float.*/ * Property type: float.*/
#define AI_CONFIG_PP_DB_THRESHOLD \ #define AI_CONFIG_PP_DB_THRESHOLD \
"PP_DB_THRESHOLD" "PP_DB_THRESHOLD"
// default value for AI_CONFIG_PP_LBW_MAX_WEIGHTS // default value for AI_CONFIG_PP_LBW_MAX_WEIGHTS
#if (!defined AI_DEBONE_THRESHOLD) #if (!defined AI_DEBONE_THRESHOLD)
# define AI_DEBONE_THRESHOLD 1.0f # define AI_DEBONE_THRESHOLD 1.0f
#endif // !! AI_DEBONE_THRESHOLD #endif // !! AI_DEBONE_THRESHOLD
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -353,12 +353,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* @note The default value is 0 * @note The default value is 0
* Property type: bool.*/ * Property type: bool.*/
#define AI_CONFIG_PP_DB_ALL_OR_NONE \ #define AI_CONFIG_PP_DB_ALL_OR_NONE \
"PP_DB_ALL_OR_NONE" "PP_DB_ALL_OR_NONE"
/** @brief Default value for the #AI_CONFIG_PP_ICL_PTCACHE_SIZE property /** @brief Default value for the #AI_CONFIG_PP_ICL_PTCACHE_SIZE property
*/ */
#ifndef PP_ICL_PTCACHE_SIZE #ifndef PP_ICL_PTCACHE_SIZE
# define PP_ICL_PTCACHE_SIZE 12 # define PP_ICL_PTCACHE_SIZE 12
#endif #endif
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -372,7 +372,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* performance improvements for most nVidia/AMD cards since 2002. * performance improvements for most nVidia/AMD cards since 2002.
* Property type: integer. * Property type: integer.
*/ */
#define AI_CONFIG_PP_ICL_PTCACHE_SIZE "PP_ICL_PTCACHE_SIZE" #define AI_CONFIG_PP_ICL_PTCACHE_SIZE "PP_ICL_PTCACHE_SIZE"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Enumerates components of the aiScene and aiMesh data structures /** @brief Enumerates components of the aiScene and aiMesh data structures
@ -382,63 +382,63 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
enum aiComponent enum aiComponent
{ {
/** Normal vectors */ /** Normal vectors */
#ifdef SWIG #ifdef SWIG
aiComponent_NORMALS = 0x2, aiComponent_NORMALS = 0x2,
#else #else
aiComponent_NORMALS = 0x2u, aiComponent_NORMALS = 0x2u,
#endif #endif
/** Tangents and bitangents go always together ... */ /** Tangents and bitangents go always together ... */
#ifdef SWIG #ifdef SWIG
aiComponent_TANGENTS_AND_BITANGENTS = 0x4, aiComponent_TANGENTS_AND_BITANGENTS = 0x4,
#else #else
aiComponent_TANGENTS_AND_BITANGENTS = 0x4u, aiComponent_TANGENTS_AND_BITANGENTS = 0x4u,
#endif #endif
/** ALL color sets /** ALL color sets
* Use aiComponent_COLORn(N) to specify the N'th set */ * Use aiComponent_COLORn(N) to specify the N'th set */
aiComponent_COLORS = 0x8, aiComponent_COLORS = 0x8,
/** ALL texture UV sets /** ALL texture UV sets
* aiComponent_TEXCOORDn(N) to specify the N'th set */ * aiComponent_TEXCOORDn(N) to specify the N'th set */
aiComponent_TEXCOORDS = 0x10, aiComponent_TEXCOORDS = 0x10,
/** Removes all bone weights from all meshes. /** Removes all bone weights from all meshes.
* The scenegraph nodes corresponding to the bones are NOT removed. * The scenegraph nodes corresponding to the bones are NOT removed.
* use the #aiProcess_OptimizeGraph step to do this */ * use the #aiProcess_OptimizeGraph step to do this */
aiComponent_BONEWEIGHTS = 0x20, aiComponent_BONEWEIGHTS = 0x20,
/** Removes all node animations (aiScene::mAnimations). /** Removes all node animations (aiScene::mAnimations).
* The corresponding scenegraph nodes are NOT removed. * The corresponding scenegraph nodes are NOT removed.
* use the #aiProcess_OptimizeGraph step to do this */ * use the #aiProcess_OptimizeGraph step to do this */
aiComponent_ANIMATIONS = 0x40, aiComponent_ANIMATIONS = 0x40,
/** Removes all embedded textures (aiScene::mTextures) */ /** Removes all embedded textures (aiScene::mTextures) */
aiComponent_TEXTURES = 0x80, aiComponent_TEXTURES = 0x80,
/** Removes all light sources (aiScene::mLights). /** Removes all light sources (aiScene::mLights).
* The corresponding scenegraph nodes are NOT removed. * The corresponding scenegraph nodes are NOT removed.
* use the #aiProcess_OptimizeGraph step to do this */ * use the #aiProcess_OptimizeGraph step to do this */
aiComponent_LIGHTS = 0x100, aiComponent_LIGHTS = 0x100,
/** Removes all cameras (aiScene::mCameras). /** Removes all cameras (aiScene::mCameras).
* The corresponding scenegraph nodes are NOT removed. * The corresponding scenegraph nodes are NOT removed.
* use the #aiProcess_OptimizeGraph step to do this */ * use the #aiProcess_OptimizeGraph step to do this */
aiComponent_CAMERAS = 0x200, aiComponent_CAMERAS = 0x200,
/** Removes all meshes (aiScene::mMeshes). */ /** Removes all meshes (aiScene::mMeshes). */
aiComponent_MESHES = 0x400, aiComponent_MESHES = 0x400,
/** Removes all materials. One default material will /** Removes all materials. One default material will
* be generated, so aiScene::mNumMaterials will be 1. */ * be generated, so aiScene::mNumMaterials will be 1. */
aiComponent_MATERIALS = 0x800, aiComponent_MATERIALS = 0x800,
/** This value is not used. It is just there to force the /** This value is not used. It is just there to force the
* compiler to map this enum to a 32 Bit integer. */ * compiler to map this enum to a 32 Bit integer. */
#ifndef SWIG #ifndef SWIG
_aiComponent_Force32Bit = 0x9fffffff _aiComponent_Force32Bit = 0x9fffffff
#endif #endif
}; };
@ -460,8 +460,8 @@ enum aiComponent
* of the flags defined above) the import FAILS. Mainly because there is * of the flags defined above) the import FAILS. Mainly because there is
* no data to work on anymore ... * no data to work on anymore ...
*/ */
#define AI_CONFIG_PP_RVC_FLAGS \ #define AI_CONFIG_PP_RVC_FLAGS \
"PP_RVC_FLAGS" "PP_RVC_FLAGS"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Input parameter to the #aiProcess_SortByPType step: /** @brief Input parameter to the #aiProcess_SortByPType step:
@ -472,8 +472,8 @@ enum aiComponent
* be to exclude all line and point meshes from the import. This * be to exclude all line and point meshes from the import. This
* is an integer property, its default value is 0. * is an integer property, its default value is 0.
*/ */
#define AI_CONFIG_PP_SBP_REMOVE \ #define AI_CONFIG_PP_SBP_REMOVE \
"PP_SBP_REMOVE" "PP_SBP_REMOVE"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Input parameter to the #aiProcess_FindInvalidData step: /** @brief Input parameter to the #aiProcess_FindInvalidData step:
@ -484,8 +484,8 @@ enum aiComponent
* abs(n0-n1)>epsilon holds true for all vector respectively quaternion * abs(n0-n1)>epsilon holds true for all vector respectively quaternion
* components. The default value is 0.f - comparisons are exact then. * components. The default value is 0.f - comparisons are exact then.
*/ */
#define AI_CONFIG_PP_FID_ANIM_ACCURACY \ #define AI_CONFIG_PP_FID_ANIM_ACCURACY \
"PP_FID_ANIM_ACCURACY" "PP_FID_ANIM_ACCURACY"
// TransformUVCoords evaluates UV scalings // TransformUVCoords evaluates UV scalings
@ -508,8 +508,8 @@ enum aiComponent
* property, of course). By default all transformations are enabled * property, of course). By default all transformations are enabled
* (AI_UVTRAFO_ALL). * (AI_UVTRAFO_ALL).
*/ */
#define AI_CONFIG_PP_TUV_EVALUATE \ #define AI_CONFIG_PP_TUV_EVALUATE \
"PP_TUV_EVALUATE" "PP_TUV_EVALUATE"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief A hint to assimp to favour speed against import quality. /** @brief A hint to assimp to favour speed against import quality.
@ -520,7 +520,7 @@ enum aiComponent
* This property is expected to be an integer, != 0 stands for true. * This property is expected to be an integer, != 0 stands for true.
* The default value is 0. * The default value is 0.
*/ */
#define AI_CONFIG_FAVOUR_SPEED \ #define AI_CONFIG_FAVOUR_SPEED \
"FAVOUR_SPEED" "FAVOUR_SPEED"
@ -538,7 +538,7 @@ enum aiComponent
* Property type: bool * Property type: bool
*/ */
#define AI_CONFIG_IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS \ #define AI_CONFIG_IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS \
"IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS" "IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Set whether the fbx importer will read all materials present in the /** @brief Set whether the fbx importer will read all materials present in the
@ -550,7 +550,7 @@ enum aiComponent
* Property type: bool * Property type: bool
*/ */
#define AI_CONFIG_IMPORT_FBX_READ_ALL_MATERIALS \ #define AI_CONFIG_IMPORT_FBX_READ_ALL_MATERIALS \
"IMPORT_FBX_READ_ALL_MATERIALS" "IMPORT_FBX_READ_ALL_MATERIALS"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Set whether the fbx importer will read materials. /** @brief Set whether the fbx importer will read materials.
@ -559,7 +559,7 @@ enum aiComponent
* Property type: bool * Property type: bool
*/ */
#define AI_CONFIG_IMPORT_FBX_READ_MATERIALS \ #define AI_CONFIG_IMPORT_FBX_READ_MATERIALS \
"IMPORT_FBX_READ_MATERIALS" "IMPORT_FBX_READ_MATERIALS"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Set whether the fbx importer will read cameras. /** @brief Set whether the fbx importer will read cameras.
@ -568,7 +568,7 @@ enum aiComponent
* Property type: bool * Property type: bool
*/ */
#define AI_CONFIG_IMPORT_FBX_READ_CAMERAS \ #define AI_CONFIG_IMPORT_FBX_READ_CAMERAS \
"IMPORT_FBX_READ_CAMERAS" "IMPORT_FBX_READ_CAMERAS"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Set whether the fbx importer will read light sources. /** @brief Set whether the fbx importer will read light sources.
@ -577,7 +577,7 @@ enum aiComponent
* Property type: bool * Property type: bool
*/ */
#define AI_CONFIG_IMPORT_FBX_READ_LIGHTS \ #define AI_CONFIG_IMPORT_FBX_READ_LIGHTS \
"IMPORT_FBX_READ_LIGHTS" "IMPORT_FBX_READ_LIGHTS"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Set whether the fbx importer will read animations. /** @brief Set whether the fbx importer will read animations.
@ -586,7 +586,7 @@ enum aiComponent
* Property type: bool * Property type: bool
*/ */
#define AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS \ #define AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS \
"IMPORT_FBX_READ_ANIMATIONS" "IMPORT_FBX_READ_ANIMATIONS"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Set whether the fbx importer will act in strict mode in which only /** @brief Set whether the fbx importer will act in strict mode in which only
@ -598,7 +598,7 @@ enum aiComponent
* Property type: bool * Property type: bool
*/ */
#define AI_CONFIG_IMPORT_FBX_STRICT_MODE \ #define AI_CONFIG_IMPORT_FBX_STRICT_MODE \
"IMPORT_FBX_STRICT_MODE" "IMPORT_FBX_STRICT_MODE"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Set whether the fbx importer will preserve pivot points for /** @brief Set whether the fbx importer will preserve pivot points for
@ -609,7 +609,7 @@ enum aiComponent
* Property type: bool * Property type: bool
*/ */
#define AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS \ #define AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS \
"IMPORT_FBX_PRESERVE_PIVOTS" "IMPORT_FBX_PRESERVE_PIVOTS"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Specifies whether the importer will drop empty animation curves or /** @brief Specifies whether the importer will drop empty animation curves or
@ -620,7 +620,7 @@ enum aiComponent
* Property type: bool * Property type: bool
*/ */
#define AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES \ #define AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES \
"IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES" "IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES"
@ -637,14 +637,14 @@ enum aiComponent
* want to override the global setting). * want to override the global setting).
* Property type: integer. * Property type: integer.
*/ */
#define AI_CONFIG_IMPORT_GLOBAL_KEYFRAME "IMPORT_GLOBAL_KEYFRAME" #define AI_CONFIG_IMPORT_GLOBAL_KEYFRAME "IMPORT_GLOBAL_KEYFRAME"
#define AI_CONFIG_IMPORT_MD3_KEYFRAME "IMPORT_MD3_KEYFRAME" #define AI_CONFIG_IMPORT_MD3_KEYFRAME "IMPORT_MD3_KEYFRAME"
#define AI_CONFIG_IMPORT_MD2_KEYFRAME "IMPORT_MD2_KEYFRAME" #define AI_CONFIG_IMPORT_MD2_KEYFRAME "IMPORT_MD2_KEYFRAME"
#define AI_CONFIG_IMPORT_MDL_KEYFRAME "IMPORT_MDL_KEYFRAME" #define AI_CONFIG_IMPORT_MDL_KEYFRAME "IMPORT_MDL_KEYFRAME"
#define AI_CONFIG_IMPORT_MDC_KEYFRAME "IMPORT_MDC_KEYFRAME" #define AI_CONFIG_IMPORT_MDC_KEYFRAME "IMPORT_MDC_KEYFRAME"
#define AI_CONFIG_IMPORT_SMD_KEYFRAME "IMPORT_SMD_KEYFRAME" #define AI_CONFIG_IMPORT_SMD_KEYFRAME "IMPORT_SMD_KEYFRAME"
#define AI_CONFIG_IMPORT_UNREAL_KEYFRAME "IMPORT_UNREAL_KEYFRAME" #define AI_CONFIG_IMPORT_UNREAL_KEYFRAME "IMPORT_UNREAL_KEYFRAME"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -653,8 +653,8 @@ enum aiComponent
* *
* Property type: bool. Default value: true. * Property type: bool. Default value: true.
*/ */
#define AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL \ #define AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL \
"IMPORT_AC_SEPARATE_BFCULL" "IMPORT_AC_SEPARATE_BFCULL"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Configures whether the AC loader evaluates subdivision surfaces ( /** @brief Configures whether the AC loader evaluates subdivision surfaces (
@ -664,8 +664,8 @@ enum aiComponent
* *
* * Property type: bool. Default value: true. * * Property type: bool. Default value: true.
*/ */
#define AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION \ #define AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION \
"IMPORT_AC_EVAL_SUBDIVISION" "IMPORT_AC_EVAL_SUBDIVISION"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Configures the UNREAL 3D loader to separate faces with different /** @brief Configures the UNREAL 3D loader to separate faces with different
@ -674,7 +674,7 @@ enum aiComponent
* * Property type: bool. Default value: true. * * Property type: bool. Default value: true.
*/ */
#define AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS \ #define AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS \
"UNREAL_HANDLE_FLAGS" "UNREAL_HANDLE_FLAGS"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Configures the terragen import plugin to compute uv's for /** @brief Configures the terragen import plugin to compute uv's for
@ -687,17 +687,17 @@ enum aiComponent
* * Property type: bool. Default value: false. * * Property type: bool. Default value: false.
*/ */
#define AI_CONFIG_IMPORT_TER_MAKE_UVS \ #define AI_CONFIG_IMPORT_TER_MAKE_UVS \
"IMPORT_TER_MAKE_UVS" "IMPORT_TER_MAKE_UVS"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Configures the ASE loader to always reconstruct normal vectors /** @brief Configures the ASE loader to always reconstruct normal vectors
* basing on the smoothing groups loaded from the file. * basing on the smoothing groups loaded from the file.
* *
* Some ASE files have carry invalid normals, other don't. * Some ASE files have carry invalid normals, other don't.
* * Property type: bool. Default value: true. * * Property type: bool. Default value: true.
*/ */
#define AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS \ #define AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS \
"IMPORT_ASE_RECONSTRUCT_NORMALS" "IMPORT_ASE_RECONSTRUCT_NORMALS"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Configures the M3D loader to detect and process multi-part /** @brief Configures the M3D loader to detect and process multi-part
@ -709,7 +709,7 @@ enum aiComponent
* Property type: bool. Default value: true. * Property type: bool. Default value: true.
*/ */
#define AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART \ #define AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART \
"IMPORT_MD3_HANDLE_MULTIPART" "IMPORT_MD3_HANDLE_MULTIPART"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Tells the MD3 loader which skin files to load. /** @brief Tells the MD3 loader which skin files to load.
@ -721,7 +721,7 @@ enum aiComponent
* Property type: String. Default value: "default". * Property type: String. Default value: "default".
*/ */
#define AI_CONFIG_IMPORT_MD3_SKIN_NAME \ #define AI_CONFIG_IMPORT_MD3_SKIN_NAME \
"IMPORT_MD3_SKIN_NAME" "IMPORT_MD3_SKIN_NAME"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Specify the Quake 3 shader file to be used for a particular /** @brief Specify the Quake 3 shader file to be used for a particular
@ -739,7 +739,7 @@ enum aiComponent
* Property type: String. Default value: n/a. * Property type: String. Default value: n/a.
*/ */
#define AI_CONFIG_IMPORT_MD3_SHADER_SRC \ #define AI_CONFIG_IMPORT_MD3_SHADER_SRC \
"IMPORT_MD3_SHADER_SRC" "IMPORT_MD3_SHADER_SRC"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Configures the LWO loader to load just one layer from the model. /** @brief Configures the LWO loader to load just one layer from the model.
@ -752,8 +752,8 @@ enum aiComponent
* layer name may not be empty.<br> * layer name may not be empty.<br>
* Property type: Integer. Default value: all layers are loaded. * Property type: Integer. Default value: all layers are loaded.
*/ */
#define AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY \ #define AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY \
"IMPORT_LWO_ONE_LAYER_ONLY" "IMPORT_LWO_ONE_LAYER_ONLY"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Configures the MD5 loader to not load the MD5ANIM file for /** @brief Configures the MD5 loader to not load the MD5ANIM file for
@ -766,8 +766,8 @@ enum aiComponent
* *
* * Property type: bool. Default value: false. * * Property type: bool. Default value: false.
*/ */
#define AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD \ #define AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD \
"IMPORT_MD5_NO_ANIM_AUTOLOAD" "IMPORT_MD5_NO_ANIM_AUTOLOAD"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Defines the begin of the time range for which the LWS loader /** @brief Defines the begin of the time range for which the LWS loader
@ -785,10 +785,10 @@ enum aiComponent
* *
* @see AI_CONFIG_IMPORT_LWS_ANIM_END - end of the imported time range * @see AI_CONFIG_IMPORT_LWS_ANIM_END - end of the imported time range
*/ */
#define AI_CONFIG_IMPORT_LWS_ANIM_START \ #define AI_CONFIG_IMPORT_LWS_ANIM_START \
"IMPORT_LWS_ANIM_START" "IMPORT_LWS_ANIM_START"
#define AI_CONFIG_IMPORT_LWS_ANIM_END \ #define AI_CONFIG_IMPORT_LWS_ANIM_END \
"IMPORT_LWS_ANIM_END" "IMPORT_LWS_ANIM_END"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Defines the output frame rate of the IRR loader. /** @brief Defines the output frame rate of the IRR loader.
@ -798,8 +798,8 @@ enum aiComponent
* are returned by the converter.<br> * are returned by the converter.<br>
* Property type: integer. Default value: 100 * Property type: integer. Default value: 100
*/ */
#define AI_CONFIG_IMPORT_IRR_ANIM_FPS \ #define AI_CONFIG_IMPORT_IRR_ANIM_FPS \
"IMPORT_IRR_ANIM_FPS" "IMPORT_IRR_ANIM_FPS"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Ogre Importer will try to find referenced materials from this file. /** @brief Ogre Importer will try to find referenced materials from this file.
@ -811,8 +811,8 @@ enum aiComponent
* <br> * <br>
* Property type: String. Default value: Scene.material. * Property type: String. Default value: Scene.material.
*/ */
#define AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE \ #define AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE \
"IMPORT_OGRE_MATERIAL_FILE" "IMPORT_OGRE_MATERIAL_FILE"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Ogre Importer detect the texture usage from its filename. /** @brief Ogre Importer detect the texture usage from its filename.
@ -832,7 +832,7 @@ enum aiComponent
* Property type: Bool. Default value: false. * Property type: Bool. Default value: false.
*/ */
#define AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME \ #define AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME \
"IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME" "IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME"
/** @brief Specifies whether the IFC loader skips over IfcSpace elements. /** @brief Specifies whether the IFC loader skips over IfcSpace elements.
* *

314
include/assimp/defs.h
View File

@ -47,163 +47,163 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef INCLUDED_AI_DEFINES_H #ifndef INCLUDED_AI_DEFINES_H
#define INCLUDED_AI_DEFINES_H #define INCLUDED_AI_DEFINES_H
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Define ASSIMP_BUILD_NO_XX_IMPORTER to disable a specific /* Define ASSIMP_BUILD_NO_XX_IMPORTER to disable a specific
* file format loader. The loader is be excluded from the * file format loader. The loader is be excluded from the
* build in this case. 'XX' stands for the most common file * build in this case. 'XX' stands for the most common file
* extension of the file format. E.g.: * extension of the file format. E.g.:
* ASSIMP_BUILD_NO_X_IMPORTER disables the X loader. * ASSIMP_BUILD_NO_X_IMPORTER disables the X loader.
* *
* If you're unsure about that, take a look at the implementation of the * If you're unsure about that, take a look at the implementation of the
* import plugin you wish to disable. You'll find the right define in the * import plugin you wish to disable. You'll find the right define in the
* first lines of the corresponding unit. * first lines of the corresponding unit.
* *
* Other (mixed) configuration switches are listed here: * Other (mixed) configuration switches are listed here:
* ASSIMP_BUILD_NO_COMPRESSED_X * ASSIMP_BUILD_NO_COMPRESSED_X
* - Disable support for compressed X files (zip) * - Disable support for compressed X files (zip)
* ASSIMP_BUILD_NO_COMPRESSED_BLEND * ASSIMP_BUILD_NO_COMPRESSED_BLEND
* - Disable support for compressed Blender files (zip) * - Disable support for compressed Blender files (zip)
* ASSIMP_BUILD_NO_COMPRESSED_IFC * ASSIMP_BUILD_NO_COMPRESSED_IFC
* - Disable support for IFCZIP files (unzip) * - Disable support for IFCZIP files (unzip)
*/ */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
#ifndef ASSIMP_BUILD_NO_COMPRESSED_X #ifndef ASSIMP_BUILD_NO_COMPRESSED_X
# define ASSIMP_BUILD_NEED_Z_INFLATE # define ASSIMP_BUILD_NEED_Z_INFLATE
#endif #endif
#ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND #ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND
# define ASSIMP_BUILD_NEED_Z_INFLATE # define ASSIMP_BUILD_NEED_Z_INFLATE
#endif #endif
#ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC #ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
# define ASSIMP_BUILD_NEED_Z_INFLATE # define ASSIMP_BUILD_NEED_Z_INFLATE
# define ASSIMP_BUILD_NEED_UNZIP # define ASSIMP_BUILD_NEED_UNZIP
#endif #endif
#ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER #ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER
# define ASSIMP_BUILD_NEED_Z_INFLATE # define ASSIMP_BUILD_NEED_Z_INFLATE
# define ASSIMP_BUILD_NEED_UNZIP # define ASSIMP_BUILD_NEED_UNZIP
#endif #endif
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Define ASSIMP_BUILD_NO_XX_PROCESS to disable a specific /* Define ASSIMP_BUILD_NO_XX_PROCESS to disable a specific
* post processing step. This is the current list of process names ('XX'): * post processing step. This is the current list of process names ('XX'):
* CALCTANGENTS * CALCTANGENTS
* JOINVERTICES * JOINVERTICES
* TRIANGULATE * TRIANGULATE
* GENFACENORMALS * GENFACENORMALS
* GENVERTEXNORMALS * GENVERTEXNORMALS
* REMOVEVC * REMOVEVC
* SPLITLARGEMESHES * SPLITLARGEMESHES
* PRETRANSFORMVERTICES * PRETRANSFORMVERTICES
* LIMITBONEWEIGHTS * LIMITBONEWEIGHTS
* VALIDATEDS * VALIDATEDS
* IMPROVECACHELOCALITY * IMPROVECACHELOCALITY
* FIXINFACINGNORMALS * FIXINFACINGNORMALS
* REMOVE_REDUNDANTMATERIALS * REMOVE_REDUNDANTMATERIALS
* OPTIMIZEGRAPH * OPTIMIZEGRAPH
* SORTBYPTYPE * SORTBYPTYPE
* FINDINVALIDDATA * FINDINVALIDDATA
* TRANSFORMTEXCOORDS * TRANSFORMTEXCOORDS
* GENUVCOORDS * GENUVCOORDS
* ENTITYMESHBUILDER * ENTITYMESHBUILDER
* MAKELEFTHANDED * MAKELEFTHANDED
* FLIPUVS * FLIPUVS
* FLIPWINDINGORDER * FLIPWINDINGORDER
* OPTIMIZEMESHES * OPTIMIZEMESHES
* OPTIMIZEANIMS * OPTIMIZEANIMS
* OPTIMIZEGRAPH * OPTIMIZEGRAPH
* GENENTITYMESHES * GENENTITYMESHES
* FIXTEXTUREPATHS */ * FIXTEXTUREPATHS */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
#ifdef _MSC_VER #ifdef _MSC_VER
# undef ASSIMP_API # undef ASSIMP_API
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Define 'ASSIMP_BUILD_DLL_EXPORT' to build a DLL of the library */ /* Define 'ASSIMP_BUILD_DLL_EXPORT' to build a DLL of the library */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
# ifdef ASSIMP_BUILD_DLL_EXPORT # ifdef ASSIMP_BUILD_DLL_EXPORT
# define ASSIMP_API __declspec(dllexport) # define ASSIMP_API __declspec(dllexport)
# define ASSIMP_API_WINONLY __declspec(dllexport) # define ASSIMP_API_WINONLY __declspec(dllexport)
# pragma warning (disable : 4251) # pragma warning (disable : 4251)
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Define 'ASSIMP_DLL' before including Assimp to link to ASSIMP in /* Define 'ASSIMP_DLL' before including Assimp to link to ASSIMP in
* an external DLL under Windows. Default is static linkage. */ * an external DLL under Windows. Default is static linkage. */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
# elif (defined ASSIMP_DLL) # elif (defined ASSIMP_DLL)
# define ASSIMP_API __declspec(dllimport) # define ASSIMP_API __declspec(dllimport)
# define ASSIMP_API_WINONLY __declspec(dllimport) # define ASSIMP_API_WINONLY __declspec(dllimport)
# else # else
# define ASSIMP_API # define ASSIMP_API
# define ASSIMP_API_WINONLY # define ASSIMP_API_WINONLY
# endif # endif
/* Force the compiler to inline a function, if possible /* Force the compiler to inline a function, if possible
*/ */
# define AI_FORCE_INLINE __forceinline # define AI_FORCE_INLINE __forceinline
/* Tells the compiler that a function never returns. Used in code analysis /* Tells the compiler that a function never returns. Used in code analysis
* to skip dead paths (e.g. after an assertion evaluated to false). */ * to skip dead paths (e.g. after an assertion evaluated to false). */
# define AI_WONT_RETURN __declspec(noreturn) # define AI_WONT_RETURN __declspec(noreturn)
#elif defined(SWIG) #elif defined(SWIG)
/* Do nothing, the relevant defines are all in AssimpSwigPort.i */ /* Do nothing, the relevant defines are all in AssimpSwigPort.i */
#else #else
# define AI_WONT_RETURN # define AI_WONT_RETURN
# define ASSIMP_API __attribute__ ((visibility("default"))) # define ASSIMP_API __attribute__ ((visibility("default")))
# define ASSIMP_API_WINONLY # define ASSIMP_API_WINONLY
# define AI_FORCE_INLINE inline # define AI_FORCE_INLINE inline
#endif // (defined _MSC_VER) #endif // (defined _MSC_VER)
#ifdef __GNUC__ #ifdef __GNUC__
# define AI_WONT_RETURN_SUFFIX __attribute__((noreturn)) # define AI_WONT_RETURN_SUFFIX __attribute__((noreturn))
#else #else
# define AI_WONT_RETURN_SUFFIX # define AI_WONT_RETURN_SUFFIX
#endif // (defined __clang__) #endif // (defined __clang__)
#ifdef __cplusplus #ifdef __cplusplus
/* No explicit 'struct' and 'enum' tags for C++, this keeps showing up /* No explicit 'struct' and 'enum' tags for C++, this keeps showing up
* in doxydocs. * in doxydocs.
*/ */
# define C_STRUCT # define C_STRUCT
# define C_ENUM # define C_ENUM
#else #else
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* To build the documentation, make sure ASSIMP_DOXYGEN_BUILD /* To build the documentation, make sure ASSIMP_DOXYGEN_BUILD
* is defined by Doxygen's preprocessor. The corresponding * is defined by Doxygen's preprocessor. The corresponding
* entries in the DOXYFILE are: */ * entries in the DOXYFILE are: */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
#if 0 #if 0
ENABLE_PREPROCESSING = YES ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = YES MACRO_EXPANSION = YES
EXPAND_ONLY_PREDEF = YES EXPAND_ONLY_PREDEF = YES
SEARCH_INCLUDES = YES SEARCH_INCLUDES = YES
INCLUDE_PATH = INCLUDE_PATH =
INCLUDE_FILE_PATTERNS = INCLUDE_FILE_PATTERNS =
PREDEFINED = ASSIMP_DOXYGEN_BUILD=1 PREDEFINED = ASSIMP_DOXYGEN_BUILD=1
EXPAND_AS_DEFINED = C_STRUCT C_ENUM EXPAND_AS_DEFINED = C_STRUCT C_ENUM
SKIP_FUNCTION_MACROS = YES SKIP_FUNCTION_MACROS = YES
#endif #endif
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Doxygen gets confused if we use c-struct typedefs to avoid /* Doxygen gets confused if we use c-struct typedefs to avoid
* the explicit 'struct' notation. This trick here has the same * the explicit 'struct' notation. This trick here has the same
* effect as the TYPEDEF_HIDES_STRUCT option, but we don't need * effect as the TYPEDEF_HIDES_STRUCT option, but we don't need
* to typedef all structs/enums. */ * to typedef all structs/enums. */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
# if (defined ASSIMP_DOXYGEN_BUILD) # if (defined ASSIMP_DOXYGEN_BUILD)
# define C_STRUCT # define C_STRUCT
# define C_ENUM # define C_ENUM
# else # else
# define C_STRUCT struct # define C_STRUCT struct
# define C_ENUM enum # define C_ENUM enum
# endif # endif
#endif #endif
#if (defined(__BORLANDC__) || defined (__BCPLUSPLUS__)) #if (defined(__BORLANDC__) || defined (__BCPLUSPLUS__))
@ -212,49 +212,49 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// "W8059 Packgr<67><72>e der Struktur ge<67>ndert" // "W8059 Packgr<67><72>e der Struktur ge<67>ndert"
#endif #endif
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Define 'ASSIMP_BUILD_BOOST_WORKAROUND' to compile assimp /* Define 'ASSIMP_BUILD_BOOST_WORKAROUND' to compile assimp
* without boost. This is done by using a few workaround * without boost. This is done by using a few workaround
* classes and brings some limitations (e.g. some logging won't be done, * classes and brings some limitations (e.g. some logging won't be done,
* the library won't utilize threads or be threadsafe at all). * the library won't utilize threads or be threadsafe at all).
* This implies the 'ASSIMP_BUILD_SINGLETHREADED' setting. */ * This implies the 'ASSIMP_BUILD_SINGLETHREADED' setting. */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
#ifdef ASSIMP_BUILD_BOOST_WORKAROUND #ifdef ASSIMP_BUILD_BOOST_WORKAROUND
// threading support requires boost // threading support requires boost
#ifndef ASSIMP_BUILD_SINGLETHREADED #ifndef ASSIMP_BUILD_SINGLETHREADED
# define ASSIMP_BUILD_SINGLETHREADED # define ASSIMP_BUILD_SINGLETHREADED
#endif #endif
#endif // !! ASSIMP_BUILD_BOOST_WORKAROUND #endif // !! ASSIMP_BUILD_BOOST_WORKAROUND
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Define ASSIMP_BUILD_SINGLETHREADED to compile assimp /* Define ASSIMP_BUILD_SINGLETHREADED to compile assimp
* without threading support. The library doesn't utilize * without threading support. The library doesn't utilize
* threads then and is itself not threadsafe. * threads then and is itself not threadsafe.
* If this flag is specified boost::threads is *not* required. */ * If this flag is specified boost::threads is *not* required. */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
#ifndef ASSIMP_BUILD_SINGLETHREADED #ifndef ASSIMP_BUILD_SINGLETHREADED
# define ASSIMP_BUILD_SINGLETHREADED # define ASSIMP_BUILD_SINGLETHREADED
#endif #endif
#if defined(_DEBUG) || ! defined(NDEBUG) #if defined(_DEBUG) || ! defined(NDEBUG)
# define ASSIMP_BUILD_DEBUG # define ASSIMP_BUILD_DEBUG
#endif #endif
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Useful constants */ /* Useful constants */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* This is PI. Hi PI. */ /* This is PI. Hi PI. */
#define AI_MATH_PI (3.141592653589793238462643383279 ) #define AI_MATH_PI (3.141592653589793238462643383279 )
#define AI_MATH_TWO_PI (AI_MATH_PI * 2.0) #define AI_MATH_TWO_PI (AI_MATH_PI * 2.0)
#define AI_MATH_HALF_PI (AI_MATH_PI * 0.5) #define AI_MATH_HALF_PI (AI_MATH_PI * 0.5)
/* And this is to avoid endless casts to float */ /* And this is to avoid endless casts to float */
#define AI_MATH_PI_F (3.1415926538f) #define AI_MATH_PI_F (3.1415926538f)
#define AI_MATH_TWO_PI_F (AI_MATH_PI_F * 2.0f) #define AI_MATH_TWO_PI_F (AI_MATH_PI_F * 2.0f)
#define AI_MATH_HALF_PI_F (AI_MATH_PI_F * 0.5f) #define AI_MATH_HALF_PI_F (AI_MATH_PI_F * 0.5f)
/* Tiny macro to convert from radians to degrees and back */ /* Tiny macro to convert from radians to degrees and back */
#define AI_DEG_TO_RAD(x) ((x)*0.0174532925f) #define AI_DEG_TO_RAD(x) ((x)*0.0174532925f)
@ -262,18 +262,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/* Support for big-endian builds */ /* Support for big-endian builds */
#if defined(__BYTE_ORDER__) #if defined(__BYTE_ORDER__)
# if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) # if (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
# if !defined(__BIG_ENDIAN__) # if !defined(__BIG_ENDIAN__)
# define __BIG_ENDIAN__ # define __BIG_ENDIAN__
# endif # endif
# else /* little endian */ # else /* little endian */
# if defined (__BIG_ENDIAN__) # if defined (__BIG_ENDIAN__)
# undef __BIG_ENDIAN__ # undef __BIG_ENDIAN__
# endif # endif
# endif # endif
#endif #endif
#if defined(__BIG_ENDIAN__) #if defined(__BIG_ENDIAN__)
# define AI_BUILD_BIG_ENDIAN # define AI_BUILD_BIG_ENDIAN
#endif #endif
#endif // !! INCLUDED_AI_DEFINES_H #endif // !! INCLUDED_AI_DEFINES_H

112
include/assimp/importerdesc.h
View File

@ -50,29 +50,29 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* common to many importers*/ * common to many importers*/
enum aiImporterFlags enum aiImporterFlags
{ {
/** Indicates that there is a textual encoding of the /** Indicates that there is a textual encoding of the
* file format; and that it is supported.*/ * file format; and that it is supported.*/
aiImporterFlags_SupportTextFlavour = 0x1, aiImporterFlags_SupportTextFlavour = 0x1,
/** Indicates that there is a binary encoding of the /** Indicates that there is a binary encoding of the
* file format; and that it is supported.*/ * file format; and that it is supported.*/
aiImporterFlags_SupportBinaryFlavour = 0x2, aiImporterFlags_SupportBinaryFlavour = 0x2,
/** Indicates that there is a compressed encoding of the /** Indicates that there is a compressed encoding of the
* file format; and that it is supported.*/ * file format; and that it is supported.*/
aiImporterFlags_SupportCompressedFlavour = 0x4, aiImporterFlags_SupportCompressedFlavour = 0x4,
/** Indicates that the importer reads only a very particular /** Indicates that the importer reads only a very particular
* subset of the file format. This happens commonly for * subset of the file format. This happens commonly for
* declarative or procedural formats which cannot easily * declarative or procedural formats which cannot easily
* be mapped to #aiScene */ * be mapped to #aiScene */
aiImporterFlags_LimitedSupport = 0x8, aiImporterFlags_LimitedSupport = 0x8,
/** Indicates that the importer is highly experimental and /** Indicates that the importer is highly experimental and
* should be used with care. This only happens for trunk * should be used with care. This only happens for trunk
* (i.e. SVN) versions, experimental code is not included * (i.e. SVN) versions, experimental code is not included
* in releases. */ * in releases. */
aiImporterFlags_Experimental = 0x10 aiImporterFlags_Experimental = 0x10
}; };
@ -86,50 +86,50 @@ enum aiImporterFlags
* characteristics. */ * characteristics. */
struct aiImporterDesc struct aiImporterDesc
{ {
/** Full name of the importer (i.e. Blender3D importer)*/ /** Full name of the importer (i.e. Blender3D importer)*/
const char* mName; const char* mName;
/** Original author (left blank if unknown or whole assimp team) */ /** Original author (left blank if unknown or whole assimp team) */
const char* mAuthor; const char* mAuthor;
/** Current maintainer, left blank if the author maintains */ /** Current maintainer, left blank if the author maintains */
const char* mMaintainer; const char* mMaintainer;
/** Implementation comments, i.e. unimplemented features*/ /** Implementation comments, i.e. unimplemented features*/
const char* mComments; const char* mComments;
/** These flags indicate some characteristics common to many /** These flags indicate some characteristics common to many
importers. */ importers. */
unsigned int mFlags; unsigned int mFlags;
/** Minimum format version that can be loaded im major.minor format, /** Minimum format version that can be loaded im major.minor format,
both are set to 0 if there is either no version scheme both are set to 0 if there is either no version scheme
or if the loader doesn't care. */ or if the loader doesn't care. */
unsigned int mMinMajor; unsigned int mMinMajor;
unsigned int mMinMinor; unsigned int mMinMinor;
/** Maximum format version that can be loaded im major.minor format, /** Maximum format version that can be loaded im major.minor format,
both are set to 0 if there is either no version scheme both are set to 0 if there is either no version scheme
or if the loader doesn't care. Loaders that expect to be or if the loader doesn't care. Loaders that expect to be
forward-compatible to potential future format versions should forward-compatible to potential future format versions should
indicate zero, otherwise they should specify the current indicate zero, otherwise they should specify the current
maximum version.*/ maximum version.*/
unsigned int mMaxMajor; unsigned int mMaxMajor;
unsigned int mMaxMinor; unsigned int mMaxMinor;
/** List of file extensions this importer can handle. /** List of file extensions this importer can handle.
List entries are separated by space characters. List entries are separated by space characters.
All entries are lower case without a leading dot (i.e. All entries are lower case without a leading dot (i.e.
"xml dae" would be a valid value. Note that multiple "xml dae" would be a valid value. Note that multiple
importers may respond to the same file extension - importers may respond to the same file extension -
assimp calls all importers in the order in which they assimp calls all importers in the order in which they
are registered and each importer gets the opportunity are registered and each importer gets the opportunity
to load the file until one importer "claims" the file. Apart to load the file until one importer "claims" the file. Apart
from file extension checks, importers typically use from file extension checks, importers typically use
other methods to quickly reject files (i.e. magic other methods to quickly reject files (i.e. magic
words) so this does not mean that common or generic words) so this does not mean that common or generic
file extensions such as XML would be tediously slow. */ file extensions such as XML would be tediously slow. */
const char* mFileExtensions; const char* mFileExtensions;
}; };
/** \brief Returns the Importer description for a given extension. /** \brief Returns the Importer description for a given extension.

264
include/assimp/light.h
View File

@ -57,37 +57,37 @@ extern "C" {
*/ */
enum aiLightSourceType enum aiLightSourceType
{ {
aiLightSource_UNDEFINED = 0x0, aiLightSource_UNDEFINED = 0x0,
//! A directional light source has a well-defined direction //! A directional light source has a well-defined direction
//! but is infinitely far away. That's quite a good //! but is infinitely far away. That's quite a good
//! approximation for sun light. //! approximation for sun light.
aiLightSource_DIRECTIONAL = 0x1, aiLightSource_DIRECTIONAL = 0x1,
//! A point light source has a well-defined position //! A point light source has a well-defined position
//! in space but no direction - it emits light in all //! in space but no direction - it emits light in all
//! directions. A normal bulb is a point light. //! directions. A normal bulb is a point light.
aiLightSource_POINT = 0x2, aiLightSource_POINT = 0x2,
//! A spot light source emits light in a specific //! A spot light source emits light in a specific
//! angle. It has a position and a direction it is pointing to. //! angle. It has a position and a direction it is pointing to.
//! A good example for a spot light is a light spot in //! A good example for a spot light is a light spot in
//! sport arenas. //! sport arenas.
aiLightSource_SPOT = 0x3, aiLightSource_SPOT = 0x3,
//! The generic light level of the world, including the bounces //! The generic light level of the world, including the bounces
//! of all other lightsources. //! of all other lightsources.
//! Typically, there's at most one ambient light in a scene. //! Typically, there's at most one ambient light in a scene.
//! This light type doesn't have a valid position, direction, or //! This light type doesn't have a valid position, direction, or
//! other properties, just a color. //! other properties, just a color.
aiLightSource_AMBIENT = 0x4, aiLightSource_AMBIENT = 0x4,
/** This value is not used. It is just there to force the /** This value is not used. It is just there to force the
* compiler to map this enum to a 32 Bit integer. * compiler to map this enum to a 32 Bit integer.
*/ */
#ifndef SWIG #ifndef SWIG
_aiLightSource_Force32Bit = INT_MAX _aiLightSource_Force32Bit = INT_MAX
#endif #endif
}; };
@ -106,128 +106,128 @@ enum aiLightSourceType
*/ */
struct aiLight struct aiLight
{ {
/** The name of the light source. /** The name of the light source.
* *
* There must be a node in the scenegraph with the same name. * There must be a node in the scenegraph with the same name.
* This node specifies the position of the light in the scene * This node specifies the position of the light in the scene
* hierarchy and can be animated. * hierarchy and can be animated.
*/ */
C_STRUCT aiString mName; C_STRUCT aiString mName;
/** The type of the light source. /** The type of the light source.
* *
* aiLightSource_UNDEFINED is not a valid value for this member. * aiLightSource_UNDEFINED is not a valid value for this member.
*/ */
C_ENUM aiLightSourceType mType; C_ENUM aiLightSourceType mType;
/** Position of the light source in space. Relative to the /** Position of the light source in space. Relative to the
* transformation of the node corresponding to the light. * transformation of the node corresponding to the light.
* *
* The position is undefined for directional lights. * The position is undefined for directional lights.
*/ */
C_STRUCT aiVector3D mPosition; C_STRUCT aiVector3D mPosition;
/** Direction of the light source in space. Relative to the /** Direction of the light source in space. Relative to the
* transformation of the node corresponding to the light. * transformation of the node corresponding to the light.
* *
* The direction is undefined for point lights. The vector * The direction is undefined for point lights. The vector
* may be normalized, but it needn't. * may be normalized, but it needn't.
*/ */
C_STRUCT aiVector3D mDirection; C_STRUCT aiVector3D mDirection;
/** Constant light attenuation factor. /** Constant light attenuation factor.
* *
* The intensity of the light source at a given distance 'd' from * The intensity of the light source at a given distance 'd' from
* the light's position is * the light's position is
* @code * @code
* Atten = 1/( att0 + att1 * d + att2 * d*d) * Atten = 1/( att0 + att1 * d + att2 * d*d)
* @endcode * @endcode
* This member corresponds to the att0 variable in the equation. * This member corresponds to the att0 variable in the equation.
* Naturally undefined for directional lights. * Naturally undefined for directional lights.
*/ */
float mAttenuationConstant; float mAttenuationConstant;
/** Linear light attenuation factor. /** Linear light attenuation factor.
* *
* The intensity of the light source at a given distance 'd' from * The intensity of the light source at a given distance 'd' from
* the light's position is * the light's position is
* @code * @code
* Atten = 1/( att0 + att1 * d + att2 * d*d) * Atten = 1/( att0 + att1 * d + att2 * d*d)
* @endcode * @endcode
* This member corresponds to the att1 variable in the equation. * This member corresponds to the att1 variable in the equation.
* Naturally undefined for directional lights. * Naturally undefined for directional lights.
*/ */
float mAttenuationLinear; float mAttenuationLinear;
/** Quadratic light attenuation factor. /** Quadratic light attenuation factor.
* *
* The intensity of the light source at a given distance 'd' from * The intensity of the light source at a given distance 'd' from
* the light's position is * the light's position is
* @code * @code
* Atten = 1/( att0 + att1 * d + att2 * d*d) * Atten = 1/( att0 + att1 * d + att2 * d*d)
* @endcode * @endcode
* This member corresponds to the att2 variable in the equation. * This member corresponds to the att2 variable in the equation.
* Naturally undefined for directional lights. * Naturally undefined for directional lights.
*/ */
float mAttenuationQuadratic; float mAttenuationQuadratic;
/** Diffuse color of the light source /** Diffuse color of the light source
* *
* The diffuse light color is multiplied with the diffuse * The diffuse light color is multiplied with the diffuse
* material color to obtain the final color that contributes * material color to obtain the final color that contributes
* to the diffuse shading term. * to the diffuse shading term.
*/ */
C_STRUCT aiColor3D mColorDiffuse; C_STRUCT aiColor3D mColorDiffuse;
/** Specular color of the light source /** Specular color of the light source
* *
* The specular light color is multiplied with the specular * The specular light color is multiplied with the specular
* material color to obtain the final color that contributes * material color to obtain the final color that contributes
* to the specular shading term. * to the specular shading term.
*/ */
C_STRUCT aiColor3D mColorSpecular; C_STRUCT aiColor3D mColorSpecular;
/** Ambient color of the light source /** Ambient color of the light source
* *
* The ambient light color is multiplied with the ambient * The ambient light color is multiplied with the ambient
* material color to obtain the final color that contributes * material color to obtain the final color that contributes
* to the ambient shading term. Most renderers will ignore * to the ambient shading term. Most renderers will ignore
* this value it, is just a remaining of the fixed-function pipeline * this value it, is just a remaining of the fixed-function pipeline
* that is still supported by quite many file formats. * that is still supported by quite many file formats.
*/ */
C_STRUCT aiColor3D mColorAmbient; C_STRUCT aiColor3D mColorAmbient;
/** Inner angle of a spot light's light cone. /** Inner angle of a spot light's light cone.
* *
* The spot light has maximum influence on objects inside this * The spot light has maximum influence on objects inside this
* angle. The angle is given in radians. It is 2PI for point * angle. The angle is given in radians. It is 2PI for point
* lights and undefined for directional lights. * lights and undefined for directional lights.
*/ */
float mAngleInnerCone; float mAngleInnerCone;
/** Outer angle of a spot light's light cone. /** Outer angle of a spot light's light cone.
* *
* The spot light does not affect objects outside this angle. * The spot light does not affect objects outside this angle.
* The angle is given in radians. It is 2PI for point lights and * The angle is given in radians. It is 2PI for point lights and
* undefined for directional lights. The outer angle must be * undefined for directional lights. The outer angle must be
* greater than or equal to the inner angle. * greater than or equal to the inner angle.
* It is assumed that the application uses a smooth * It is assumed that the application uses a smooth
* interpolation between the inner and the outer cone of the * interpolation between the inner and the outer cone of the
* spot light. * spot light.
*/ */
float mAngleOuterCone; float mAngleOuterCone;
#ifdef __cplusplus #ifdef __cplusplus
aiLight() aiLight()
: mType (aiLightSource_UNDEFINED) : mType (aiLightSource_UNDEFINED)
, mAttenuationConstant (0.f) , mAttenuationConstant (0.f)
, mAttenuationLinear (1.f) , mAttenuationLinear (1.f)
, mAttenuationQuadratic (0.f) , mAttenuationQuadratic (0.f)
, mAngleInnerCone ((float)AI_MATH_TWO_PI) , mAngleInnerCone ((float)AI_MATH_TWO_PI)
, mAngleOuterCone ((float)AI_MATH_TWO_PI) , mAngleOuterCone ((float)AI_MATH_TWO_PI)
{ {
} }
#endif #endif
}; };

1234
include/assimp/material.h
View File

File diff suppressed because it is too large Load Diff

306
include/assimp/material.inl
View File

@ -52,212 +52,212 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
inline aiReturn aiMaterial::GetTexture( aiTextureType type, inline aiReturn aiMaterial::GetTexture( aiTextureType type,
unsigned int index, unsigned int index,
C_STRUCT aiString* path, C_STRUCT aiString* path,
aiTextureMapping* mapping /*= NULL*/, aiTextureMapping* mapping /*= NULL*/,
unsigned int* uvindex /*= NULL*/, unsigned int* uvindex /*= NULL*/,
float* blend /*= NULL*/, float* blend /*= NULL*/,
aiTextureOp* op /*= NULL*/, aiTextureOp* op /*= NULL*/,
aiTextureMapMode* mapmode /*= NULL*/) const aiTextureMapMode* mapmode /*= NULL*/) const
{ {
return ::aiGetMaterialTexture(this,type,index,path,mapping,uvindex,blend,op,mapmode); return ::aiGetMaterialTexture(this,type,index,path,mapping,uvindex,blend,op,mapmode);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline unsigned int aiMaterial::GetTextureCount(aiTextureType type) const inline unsigned int aiMaterial::GetTextureCount(aiTextureType type) const
{ {
return ::aiGetMaterialTextureCount(this,type); return ::aiGetMaterialTextureCount(this,type);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template <typename Type> template <typename Type>
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx, Type* pOut, unsigned int idx, Type* pOut,
unsigned int* pMax) const unsigned int* pMax) const
{ {
unsigned int iNum = pMax ? *pMax : 1; unsigned int iNum = pMax ? *pMax : 1;
const aiMaterialProperty* prop; const aiMaterialProperty* prop;
const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx, const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx,
(const aiMaterialProperty**)&prop); (const aiMaterialProperty**)&prop);
if ( AI_SUCCESS == ret ) { if ( AI_SUCCESS == ret ) {
if (prop->mDataLength < sizeof(Type)*iNum) { if (prop->mDataLength < sizeof(Type)*iNum) {
return AI_FAILURE; return AI_FAILURE;
} }
if (prop->mType != aiPTI_Buffer) { if (prop->mType != aiPTI_Buffer) {
return AI_FAILURE; return AI_FAILURE;
} }
iNum = std::min((size_t)iNum,prop->mDataLength / sizeof(Type)); iNum = std::min((size_t)iNum,prop->mDataLength / sizeof(Type));
::memcpy(pOut,prop->mData,iNum * sizeof(Type)); ::memcpy(pOut,prop->mData,iNum * sizeof(Type));
if (pMax) { if (pMax) {
*pMax = iNum; *pMax = iNum;
} }
} }
return ret; return ret;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template <typename Type> template <typename Type>
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,Type& pOut) const unsigned int idx,Type& pOut) const
{ {
const aiMaterialProperty* prop; const aiMaterialProperty* prop;
const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx, const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx,
(const aiMaterialProperty**)&prop); (const aiMaterialProperty**)&prop);
if ( AI_SUCCESS == ret ) { if ( AI_SUCCESS == ret ) {
if (prop->mDataLength < sizeof(Type)) { if (prop->mDataLength < sizeof(Type)) {
return AI_FAILURE; return AI_FAILURE;
} }
if (prop->mType != aiPTI_Buffer) { if (prop->mType != aiPTI_Buffer) {
return AI_FAILURE; return AI_FAILURE;
} }
::memcpy(&pOut,prop->mData,sizeof(Type)); ::memcpy(&pOut,prop->mData,sizeof(Type));
} }
return ret; return ret;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,float* pOut, unsigned int idx,float* pOut,
unsigned int* pMax) const unsigned int* pMax) const
{ {
return ::aiGetMaterialFloatArray(this,pKey,type,idx,pOut,pMax); return ::aiGetMaterialFloatArray(this,pKey,type,idx,pOut,pMax);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,int* pOut, unsigned int idx,int* pOut,
unsigned int* pMax) const unsigned int* pMax) const
{ {
return ::aiGetMaterialIntegerArray(this,pKey,type,idx,pOut,pMax); return ::aiGetMaterialIntegerArray(this,pKey,type,idx,pOut,pMax);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,float& pOut) const unsigned int idx,float& pOut) const
{ {
return aiGetMaterialFloat(this,pKey,type,idx,&pOut); return aiGetMaterialFloat(this,pKey,type,idx,&pOut);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,int& pOut) const unsigned int idx,int& pOut) const
{ {
return aiGetMaterialInteger(this,pKey,type,idx,&pOut); return aiGetMaterialInteger(this,pKey,type,idx,&pOut);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,aiColor4D& pOut) const unsigned int idx,aiColor4D& pOut) const
{ {
return aiGetMaterialColor(this,pKey,type,idx,&pOut); return aiGetMaterialColor(this,pKey,type,idx,&pOut);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,aiColor3D& pOut) const unsigned int idx,aiColor3D& pOut) const
{ {
aiColor4D c; aiColor4D c;
const aiReturn ret = aiGetMaterialColor(this,pKey,type,idx,&c); const aiReturn ret = aiGetMaterialColor(this,pKey,type,idx,&c);
pOut = aiColor3D(c.r,c.g,c.b); pOut = aiColor3D(c.r,c.g,c.b);
return ret; return ret;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,aiString& pOut) const unsigned int idx,aiString& pOut) const
{ {
return aiGetMaterialString(this,pKey,type,idx,&pOut); return aiGetMaterialString(this,pKey,type,idx,&pOut);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type, inline aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,aiUVTransform& pOut) const unsigned int idx,aiUVTransform& pOut) const
{ {
return aiGetMaterialUVTransform(this,pKey,type,idx,&pOut); return aiGetMaterialUVTransform(this,pKey,type,idx,&pOut);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<class TYPE> template<class TYPE>
aiReturn aiMaterial::AddProperty (const TYPE* pInput, aiReturn aiMaterial::AddProperty (const TYPE* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
unsigned int index) unsigned int index)
{ {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(TYPE), pNumValues * sizeof(TYPE),
pKey,type,index,aiPTI_Buffer); pKey,type,index,aiPTI_Buffer);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const float* pInput, inline aiReturn aiMaterial::AddProperty(const float* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
unsigned int index) unsigned int index)
{ {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(float), pNumValues * sizeof(float),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput, inline aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
unsigned int index) unsigned int index)
{ {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiUVTransform), pNumValues * sizeof(aiUVTransform),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const aiColor4D* pInput, inline aiReturn aiMaterial::AddProperty(const aiColor4D* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
unsigned int index) unsigned int index)
{ {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiColor4D), pNumValues * sizeof(aiColor4D),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const aiColor3D* pInput, inline aiReturn aiMaterial::AddProperty(const aiColor3D* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
unsigned int index) unsigned int index)
{ {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiColor3D), pNumValues * sizeof(aiColor3D),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const aiVector3D* pInput, inline aiReturn aiMaterial::AddProperty(const aiVector3D* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
unsigned int index) unsigned int index)
{ {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiVector3D), pNumValues * sizeof(aiVector3D),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const int* pInput, inline aiReturn aiMaterial::AddProperty(const int* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
unsigned int index) unsigned int index)
{ {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(int), pNumValues * sizeof(int),
pKey,type,index,aiPTI_Integer); pKey,type,index,aiPTI_Integer);
} }
@ -270,79 +270,79 @@ inline aiReturn aiMaterial::AddProperty(const int* pInput,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<float>(const float* pInput, inline aiReturn aiMaterial::AddProperty<float>(const float* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
unsigned int index) unsigned int index)
{ {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(float), pNumValues * sizeof(float),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput, inline aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
unsigned int index) unsigned int index)
{ {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiUVTransform), pNumValues * sizeof(aiUVTransform),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput, inline aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
unsigned int index) unsigned int index)
{ {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiColor4D), pNumValues * sizeof(aiColor4D),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput, inline aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
unsigned int index) unsigned int index)
{ {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiColor3D), pNumValues * sizeof(aiColor3D),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput, inline aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
unsigned int index) unsigned int index)
{ {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(aiVector3D), pNumValues * sizeof(aiVector3D),
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
inline aiReturn aiMaterial::AddProperty<int>(const int* pInput, inline aiReturn aiMaterial::AddProperty<int>(const int* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
unsigned int index) unsigned int index)
{ {
return AddBinaryProperty((const void*)pInput, return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(int), pNumValues * sizeof(int),
pKey,type,index,aiPTI_Integer); pKey,type,index,aiPTI_Integer);
} }
//! @endcond //! @endcond

160
include/assimp/matrix3x3.h
View File

@ -66,105 +66,105 @@ class aiMatrix3x3t
{ {
public: public:
aiMatrix3x3t () : aiMatrix3x3t () :
a1(static_cast<TReal>(1.0f)), a2(), a3(), a1(static_cast<TReal>(1.0f)), a2(), a3(),
b1(), b2(static_cast<TReal>(1.0f)), b3(), b1(), b2(static_cast<TReal>(1.0f)), b3(),
c1(), c2(), c3(static_cast<TReal>(1.0f)) {} c1(), c2(), c3(static_cast<TReal>(1.0f)) {}
aiMatrix3x3t ( TReal _a1, TReal _a2, TReal _a3, aiMatrix3x3t ( TReal _a1, TReal _a2, TReal _a3,
TReal _b1, TReal _b2, TReal _b3, TReal _b1, TReal _b2, TReal _b3,
TReal _c1, TReal _c2, TReal _c3) : TReal _c1, TReal _c2, TReal _c3) :
a1(_a1), a2(_a2), a3(_a3), a1(_a1), a2(_a2), a3(_a3),
b1(_b1), b2(_b2), b3(_b3), b1(_b1), b2(_b2), b3(_b3),
c1(_c1), c2(_c2), c3(_c3) c1(_c1), c2(_c2), c3(_c3)
{} {}
public: public:
// matrix multiplication. // matrix multiplication.
aiMatrix3x3t& operator *= (const aiMatrix3x3t& m); aiMatrix3x3t& operator *= (const aiMatrix3x3t& m);
aiMatrix3x3t operator * (const aiMatrix3x3t& m) const; aiMatrix3x3t operator * (const aiMatrix3x3t& m) const;
// array access operators // array access operators
TReal* operator[] (unsigned int p_iIndex); TReal* operator[] (unsigned int p_iIndex);
const TReal* operator[] (unsigned int p_iIndex) const; const TReal* operator[] (unsigned int p_iIndex) const;
// comparison operators // comparison operators
bool operator== (const aiMatrix4x4t<TReal>& m) const; bool operator== (const aiMatrix4x4t<TReal>& m) const;
bool operator!= (const aiMatrix4x4t<TReal>& m) const; bool operator!= (const aiMatrix4x4t<TReal>& m) const;
bool Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon = 1e-6) const; bool Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon = 1e-6) const;
template <typename TOther> template <typename TOther>
operator aiMatrix3x3t<TOther> () const; operator aiMatrix3x3t<TOther> () const;
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Construction from a 4x4 matrix. The remaining parts /** @brief Construction from a 4x4 matrix. The remaining parts
* of the matrix are ignored. * of the matrix are ignored.
*/ */
explicit aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix); explicit aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Transpose the matrix /** @brief Transpose the matrix
*/ */
aiMatrix3x3t& Transpose(); aiMatrix3x3t& Transpose();
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Invert the matrix. /** @brief Invert the matrix.
* If the matrix is not invertible all elements are set to qnan. * If the matrix is not invertible all elements are set to qnan.
* Beware, use (f != f) to check whether a TReal f is qnan. * Beware, use (f != f) to check whether a TReal f is qnan.
*/ */
aiMatrix3x3t& Inverse(); aiMatrix3x3t& Inverse();
TReal Determinant() const; TReal Determinant() const;
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a rotation matrix for a rotation around z /** @brief Returns a rotation matrix for a rotation around z
* @param a Rotation angle, in radians * @param a Rotation angle, in radians
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix3x3t& RotationZ(TReal a, aiMatrix3x3t& out); static aiMatrix3x3t& RotationZ(TReal a, aiMatrix3x3t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a rotation matrix for a rotation around /** @brief Returns a rotation matrix for a rotation around
* an arbitrary axis. * an arbitrary axis.
* *
* @param a Rotation angle, in radians * @param a Rotation angle, in radians
* @param axis Axis to rotate around * @param axis Axis to rotate around
* @param out To be filled * @param out To be filled
*/ */
static aiMatrix3x3t& Rotation( TReal a, static aiMatrix3x3t& Rotation( TReal a,
const aiVector3t<TReal>& axis, aiMatrix3x3t& out); const aiVector3t<TReal>& axis, aiMatrix3x3t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a translation matrix /** @brief Returns a translation matrix
* @param v Translation vector * @param v Translation vector
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix3x3t& Translation( const aiVector2t<TReal>& v, aiMatrix3x3t& out); static aiMatrix3x3t& Translation( const aiVector2t<TReal>& v, aiMatrix3x3t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief A function for creating a rotation matrix that rotates a /** @brief A function for creating a rotation matrix that rotates a
* vector called "from" into another vector called "to". * vector called "from" into another vector called "to".
* Input : from[3], to[3] which both must be *normalized* non-zero vectors * Input : from[3], to[3] which both must be *normalized* non-zero vectors
* Output: mtx[3][3] -- a 3x3 matrix in colum-major form * Output: mtx[3][3] -- a 3x3 matrix in colum-major form
* Authors: Tomas Möller, John Hughes * Authors: Tomas Möller, John Hughes
* "Efficiently Building a Matrix to Rotate One Vector to Another" * "Efficiently Building a Matrix to Rotate One Vector to Another"
* Journal of Graphics Tools, 4(4):1-4, 1999 * Journal of Graphics Tools, 4(4):1-4, 1999
*/ */
static aiMatrix3x3t& FromToMatrix(const aiVector3t<TReal>& from, static aiMatrix3x3t& FromToMatrix(const aiVector3t<TReal>& from,
const aiVector3t<TReal>& to, aiMatrix3x3t& out); const aiVector3t<TReal>& to, aiMatrix3x3t& out);
public: public:
TReal a1, a2, a3; TReal a1, a2, a3;
TReal b1, b2, b3; TReal b1, b2, b3;
TReal c1, c2, c3; TReal c1, c2, c3;
} PACK_STRUCT; } PACK_STRUCT;
typedef aiMatrix3x3t<float> aiMatrix3x3; typedef aiMatrix3x3t<float> aiMatrix3x3;
@ -173,9 +173,9 @@ typedef aiMatrix3x3t<float> aiMatrix3x3;
struct aiMatrix3x3 { struct aiMatrix3x3 {
float a1, a2, a3; float a1, a2, a3;
float b1, b2, b3; float b1, b2, b3;
float c1, c2, c3; float c1, c2, c3;
} PACK_STRUCT; } PACK_STRUCT;
#endif #endif

288
include/assimp/matrix3x3.inl
View File

@ -58,25 +58,25 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>::aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix) inline aiMatrix3x3t<TReal>::aiMatrix3x3t( const aiMatrix4x4t<TReal>& pMatrix)
{ {
a1 = pMatrix.a1; a2 = pMatrix.a2; a3 = pMatrix.a3; a1 = pMatrix.a1; a2 = pMatrix.a2; a3 = pMatrix.a3;
b1 = pMatrix.b1; b2 = pMatrix.b2; b3 = pMatrix.b3; b1 = pMatrix.b1; b2 = pMatrix.b2; b3 = pMatrix.b3;
c1 = pMatrix.c1; c2 = pMatrix.c2; c3 = pMatrix.c3; c1 = pMatrix.c1; c2 = pMatrix.c2; c3 = pMatrix.c3;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& m) inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& m)
{ {
*this = aiMatrix3x3t<TReal>(m.a1 * a1 + m.b1 * a2 + m.c1 * a3, *this = aiMatrix3x3t<TReal>(m.a1 * a1 + m.b1 * a2 + m.c1 * a3,
m.a2 * a1 + m.b2 * a2 + m.c2 * a3, m.a2 * a1 + m.b2 * a2 + m.c2 * a3,
m.a3 * a1 + m.b3 * a2 + m.c3 * a3, m.a3 * a1 + m.b3 * a2 + m.c3 * a3,
m.a1 * b1 + m.b1 * b2 + m.c1 * b3, m.a1 * b1 + m.b1 * b2 + m.c1 * b3,
m.a2 * b1 + m.b2 * b2 + m.c2 * b3, m.a2 * b1 + m.b2 * b2 + m.c2 * b3,
m.a3 * b1 + m.b3 * b2 + m.c3 * b3, m.a3 * b1 + m.b3 * b2 + m.c3 * b3,
m.a1 * c1 + m.b1 * c2 + m.c1 * c3, m.a1 * c1 + m.b1 * c2 + m.c1 * c3,
m.a2 * c1 + m.b2 * c2 + m.c2 * c3, m.a2 * c1 + m.b2 * c2 + m.c2 * c3,
m.a3 * c1 + m.b3 * c2 + m.c3 * c3); m.a3 * c1 + m.b3 * c2 + m.c3 * c3);
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -84,130 +84,130 @@ template <typename TReal>
template <typename TOther> template <typename TOther>
aiMatrix3x3t<TReal>::operator aiMatrix3x3t<TOther> () const aiMatrix3x3t<TReal>::operator aiMatrix3x3t<TOther> () const
{ {
return aiMatrix3x3t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3), return aiMatrix3x3t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),
static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3), static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),
static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3)); static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal> aiMatrix3x3t<TReal>::operator* (const aiMatrix3x3t<TReal>& m) const inline aiMatrix3x3t<TReal> aiMatrix3x3t<TReal>::operator* (const aiMatrix3x3t<TReal>& m) const
{ {
aiMatrix3x3t<TReal> temp( *this); aiMatrix3x3t<TReal> temp( *this);
temp *= m; temp *= m;
return temp; return temp;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) inline TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex)
{ {
return &this->a1 + p_iIndex * 3; return &this->a1 + p_iIndex * 3;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) const inline const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) const
{ {
return &this->a1 + p_iIndex * 3; return &this->a1 + p_iIndex * 3;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline bool aiMatrix3x3t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const inline bool aiMatrix3x3t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const
{ {
return a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && return a1 == m.a1 && a2 == m.a2 && a3 == m.a3 &&
b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && b1 == m.b1 && b2 == m.b2 && b3 == m.b3 &&
c1 == m.c1 && c2 == m.c2 && c3 == m.c3; c1 == m.c1 && c2 == m.c2 && c3 == m.c3;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline bool aiMatrix3x3t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const inline bool aiMatrix3x3t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const
{ {
return !(*this == m); return !(*this == m);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
inline bool aiMatrix3x3t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const { inline bool aiMatrix3x3t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
return return
std::abs(a1 - m.a1) <= epsilon && std::abs(a1 - m.a1) <= epsilon &&
std::abs(a2 - m.a2) <= epsilon && std::abs(a2 - m.a2) <= epsilon &&
std::abs(a3 - m.a3) <= epsilon && std::abs(a3 - m.a3) <= epsilon &&
std::abs(b1 - m.b1) <= epsilon && std::abs(b1 - m.b1) <= epsilon &&
std::abs(b2 - m.b2) <= epsilon && std::abs(b2 - m.b2) <= epsilon &&
std::abs(b3 - m.b3) <= epsilon && std::abs(b3 - m.b3) <= epsilon &&
std::abs(c1 - m.c1) <= epsilon && std::abs(c1 - m.c1) <= epsilon &&
std::abs(c2 - m.c2) <= epsilon && std::abs(c2 - m.c2) <= epsilon &&
std::abs(c3 - m.c3) <= epsilon; std::abs(c3 - m.c3) <= epsilon;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Transpose() inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Transpose()
{ {
// (TReal&) don't remove, GCC complains cause of packed fields // (TReal&) don't remove, GCC complains cause of packed fields
std::swap( (TReal&)a2, (TReal&)b1); std::swap( (TReal&)a2, (TReal&)b1);
std::swap( (TReal&)a3, (TReal&)c1); std::swap( (TReal&)a3, (TReal&)c1);
std::swap( (TReal&)b3, (TReal&)c2); std::swap( (TReal&)b3, (TReal&)c2);
return *this; return *this;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline TReal aiMatrix3x3t<TReal>::Determinant() const inline TReal aiMatrix3x3t<TReal>::Determinant() const
{ {
return a1*b2*c3 - a1*b3*c2 + a2*b3*c1 - a2*b1*c3 + a3*b1*c2 - a3*b2*c1; return a1*b2*c3 - a1*b3*c2 + a2*b3*c1 - a2*b1*c3 + a3*b1*c2 - a3*b2*c1;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Inverse() inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Inverse()
{ {
// Compute the reciprocal determinant // Compute the reciprocal determinant
TReal det = Determinant(); TReal det = Determinant();
if(det == static_cast<TReal>(0.0)) if(det == static_cast<TReal>(0.0))
{ {
// Matrix not invertible. Setting all elements to nan is not really // Matrix not invertible. Setting all elements to nan is not really
// correct in a mathematical sense; but at least qnans are easy to // correct in a mathematical sense; but at least qnans are easy to
// spot. XXX we might throw an exception instead, which would // spot. XXX we might throw an exception instead, which would
// be even much better to spot :/. // be even much better to spot :/.
const TReal nan = std::numeric_limits<TReal>::quiet_NaN(); const TReal nan = std::numeric_limits<TReal>::quiet_NaN();
*this = aiMatrix3x3t<TReal>( nan,nan,nan,nan,nan,nan,nan,nan,nan); *this = aiMatrix3x3t<TReal>( nan,nan,nan,nan,nan,nan,nan,nan,nan);
return *this; return *this;
} }
TReal invdet = static_cast<TReal>(1.0) / det; TReal invdet = static_cast<TReal>(1.0) / det;
aiMatrix3x3t<TReal> res; aiMatrix3x3t<TReal> res;
res.a1 = invdet * (b2 * c3 - b3 * c2); res.a1 = invdet * (b2 * c3 - b3 * c2);
res.a2 = -invdet * (a2 * c3 - a3 * c2); res.a2 = -invdet * (a2 * c3 - a3 * c2);
res.a3 = invdet * (a2 * b3 - a3 * b2); res.a3 = invdet * (a2 * b3 - a3 * b2);
res.b1 = -invdet * (b1 * c3 - b3 * c1); res.b1 = -invdet * (b1 * c3 - b3 * c1);
res.b2 = invdet * (a1 * c3 - a3 * c1); res.b2 = invdet * (a1 * c3 - a3 * c1);
res.b3 = -invdet * (a1 * b3 - a3 * b1); res.b3 = -invdet * (a1 * b3 - a3 * b1);
res.c1 = invdet * (b1 * c2 - b2 * c1); res.c1 = invdet * (b1 * c2 - b2 * c1);
res.c2 = -invdet * (a1 * c2 - a2 * c1); res.c2 = -invdet * (a1 * c2 - a2 * c1);
res.c3 = invdet * (a1 * b2 - a2 * b1); res.c3 = invdet * (a1 * b2 - a2 * b1);
*this = res; *this = res;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::RotationZ(TReal a, aiMatrix3x3t<TReal>& out) inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::RotationZ(TReal a, aiMatrix3x3t<TReal>& out)
{ {
out.a1 = out.b2 = std::cos(a); out.a1 = out.b2 = std::cos(a);
out.b1 = std::sin(a); out.b1 = std::sin(a);
out.a2 = - out.b1; out.a2 = - out.b1;
out.a3 = out.b3 = out.c1 = out.c2 = 0.f; out.a3 = out.b3 = out.c1 = out.c2 = 0.f;
out.c3 = 1.f; out.c3 = 1.f;
return out; return out;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -230,10 +230,10 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Rotation( TReal a, const aiVect
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<TReal>& v, aiMatrix3x3t<TReal>& out) inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<TReal>& v, aiMatrix3x3t<TReal>& out)
{ {
out = aiMatrix3x3t<TReal>(); out = aiMatrix3x3t<TReal>();
out.a3 = v.x; out.a3 = v.x;
out.b3 = v.y; out.b3 = v.y;
return out; return out;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
@ -248,83 +248,83 @@ inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::Translation( const aiVector2t<T
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::FromToMatrix(const aiVector3t<TReal>& from, inline aiMatrix3x3t<TReal>& aiMatrix3x3t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
const aiVector3t<TReal>& to, aiMatrix3x3t<TReal>& mtx) const aiVector3t<TReal>& to, aiMatrix3x3t<TReal>& mtx)
{ {
const TReal e = from * to; const TReal e = from * to;
const TReal f = (e < 0)? -e:e; const TReal f = (e < 0)? -e:e;
if (f > static_cast<TReal>(1.0) - static_cast<TReal>(0.00001)) /* "from" and "to"-vector almost parallel */ if (f > static_cast<TReal>(1.0) - static_cast<TReal>(0.00001)) /* "from" and "to"-vector almost parallel */
{ {
aiVector3D u,v; /* temporary storage vectors */ aiVector3D u,v; /* temporary storage vectors */
aiVector3D x; /* vector most nearly orthogonal to "from" */ aiVector3D x; /* vector most nearly orthogonal to "from" */
x.x = (from.x > 0.0)? from.x : -from.x; x.x = (from.x > 0.0)? from.x : -from.x;
x.y = (from.y > 0.0)? from.y : -from.y; x.y = (from.y > 0.0)? from.y : -from.y;
x.z = (from.z > 0.0)? from.z : -from.z; x.z = (from.z > 0.0)? from.z : -from.z;
if (x.x < x.y) if (x.x < x.y)
{ {
if (x.x < x.z) if (x.x < x.z)
{ {
x.x = static_cast<TReal>(1.0); x.y = x.z = static_cast<TReal>(0.0); x.x = static_cast<TReal>(1.0); x.y = x.z = static_cast<TReal>(0.0);
} }
else else
{ {
x.z = static_cast<TReal>(1.0); x.y = x.z = static_cast<TReal>(0.0); x.z = static_cast<TReal>(1.0); x.y = x.z = static_cast<TReal>(0.0);
} }
} }
else else
{ {
if (x.y < x.z) if (x.y < x.z)
{ {
x.y = static_cast<TReal>(1.0); x.x = x.z = static_cast<TReal>(0.0); x.y = static_cast<TReal>(1.0); x.x = x.z = static_cast<TReal>(0.0);
} }
else else
{ {
x.z = static_cast<TReal>(1.0); x.x = x.y = static_cast<TReal>(0.0); x.z = static_cast<TReal>(1.0); x.x = x.y = static_cast<TReal>(0.0);
} }
} }
u.x = x.x - from.x; u.y = x.y - from.y; u.z = x.z - from.z; u.x = x.x - from.x; u.y = x.y - from.y; u.z = x.z - from.z;
v.x = x.x - to.x; v.y = x.y - to.y; v.z = x.z - to.z; v.x = x.x - to.x; v.y = x.y - to.y; v.z = x.z - to.z;
const TReal c1 = static_cast<TReal>(2.0) / (u * u); const TReal c1 = static_cast<TReal>(2.0) / (u * u);
const TReal c2 = static_cast<TReal>(2.0) / (v * v); const TReal c2 = static_cast<TReal>(2.0) / (v * v);
const TReal c3 = c1 * c2 * (u * v); const TReal c3 = c1 * c2 * (u * v);
for (unsigned int i = 0; i < 3; i++) for (unsigned int i = 0; i < 3; i++)
{ {
for (unsigned int j = 0; j < 3; j++) for (unsigned int j = 0; j < 3; j++)
{ {
mtx[i][j] = - c1 * u[i] * u[j] - c2 * v[i] * v[j] mtx[i][j] = - c1 * u[i] * u[j] - c2 * v[i] * v[j]
+ c3 * v[i] * u[j]; + c3 * v[i] * u[j];
} }
mtx[i][i] += static_cast<TReal>(1.0); mtx[i][i] += static_cast<TReal>(1.0);
} }
} }
else /* the most common case, unless "from"="to", or "from"=-"to" */ else /* the most common case, unless "from"="to", or "from"=-"to" */
{ {
const aiVector3D v = from ^ to; const aiVector3D v = from ^ to;
/* ... use this hand optimized version (9 mults less) */ /* ... use this hand optimized version (9 mults less) */
const TReal h = static_cast<TReal>(1.0)/(static_cast<TReal>(1.0) + e); /* optimization by Gottfried Chen */ const TReal h = static_cast<TReal>(1.0)/(static_cast<TReal>(1.0) + e); /* optimization by Gottfried Chen */
const TReal hvx = h * v.x; const TReal hvx = h * v.x;
const TReal hvz = h * v.z; const TReal hvz = h * v.z;
const TReal hvxy = hvx * v.y; const TReal hvxy = hvx * v.y;
const TReal hvxz = hvx * v.z; const TReal hvxz = hvx * v.z;
const TReal hvyz = hvz * v.y; const TReal hvyz = hvz * v.y;
mtx[0][0] = e + hvx * v.x; mtx[0][0] = e + hvx * v.x;
mtx[0][1] = hvxy - v.z; mtx[0][1] = hvxy - v.z;
mtx[0][2] = hvxz + v.y; mtx[0][2] = hvxz + v.y;
mtx[1][0] = hvxy + v.z; mtx[1][0] = hvxy + v.z;
mtx[1][1] = e + h * v.y * v.y; mtx[1][1] = e + h * v.y * v.y;
mtx[1][2] = hvyz - v.x; mtx[1][2] = hvyz - v.x;
mtx[2][0] = hvxz - v.y; mtx[2][0] = hvxz - v.y;
mtx[2][1] = hvyz + v.x; mtx[2][1] = hvyz + v.x;
mtx[2][2] = e + hvz * v.z; mtx[2][2] = e + hvz * v.z;
} }
return mtx; return mtx;
} }

264
include/assimp/matrix4x4.h
View File

@ -67,166 +67,166 @@ class aiMatrix4x4t
{ {
public: public:
/** set to identity */ /** set to identity */
aiMatrix4x4t (); aiMatrix4x4t ();
/** construction from single values */ /** construction from single values */
aiMatrix4x4t ( TReal _a1, TReal _a2, TReal _a3, TReal _a4, aiMatrix4x4t ( TReal _a1, TReal _a2, TReal _a3, TReal _a4,
TReal _b1, TReal _b2, TReal _b3, TReal _b4, TReal _b1, TReal _b2, TReal _b3, TReal _b4,
TReal _c1, TReal _c2, TReal _c3, TReal _c4, TReal _c1, TReal _c2, TReal _c3, TReal _c4,
TReal _d1, TReal _d2, TReal _d3, TReal _d4); TReal _d1, TReal _d2, TReal _d3, TReal _d4);
/** construction from 3x3 matrix, remaining elements are set to identity */ /** construction from 3x3 matrix, remaining elements are set to identity */
explicit aiMatrix4x4t( const aiMatrix3x3t<TReal>& m); explicit aiMatrix4x4t( const aiMatrix3x3t<TReal>& m);
/** construction from position, rotation and scaling components /** construction from position, rotation and scaling components
* @param scaling The scaling for the x,y,z axes * @param scaling The scaling for the x,y,z axes
* @param rotation The rotation as a hamilton quaternion * @param rotation The rotation as a hamilton quaternion
* @param position The position for the x,y,z axes * @param position The position for the x,y,z axes
*/ */
aiMatrix4x4t(const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation, aiMatrix4x4t(const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation,
const aiVector3t<TReal>& position); const aiVector3t<TReal>& position);
public: public:
// array access operators // array access operators
TReal* operator[] (unsigned int p_iIndex); TReal* operator[] (unsigned int p_iIndex);
const TReal* operator[] (unsigned int p_iIndex) const; const TReal* operator[] (unsigned int p_iIndex) const;
// comparison operators // comparison operators
bool operator== (const aiMatrix4x4t& m) const; bool operator== (const aiMatrix4x4t& m) const;
bool operator!= (const aiMatrix4x4t& m) const; bool operator!= (const aiMatrix4x4t& m) const;
bool Equal(const aiMatrix4x4t& m, TReal epsilon = 1e-6) const; bool Equal(const aiMatrix4x4t& m, TReal epsilon = 1e-6) const;
// matrix multiplication. // matrix multiplication.
aiMatrix4x4t& operator *= (const aiMatrix4x4t& m); aiMatrix4x4t& operator *= (const aiMatrix4x4t& m);
aiMatrix4x4t operator * (const aiMatrix4x4t& m) const; aiMatrix4x4t operator * (const aiMatrix4x4t& m) const;
template <typename TOther> template <typename TOther>
operator aiMatrix4x4t<TOther> () const; operator aiMatrix4x4t<TOther> () const;
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Transpose the matrix */ /** @brief Transpose the matrix */
aiMatrix4x4t& Transpose(); aiMatrix4x4t& Transpose();
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Invert the matrix. /** @brief Invert the matrix.
* If the matrix is not invertible all elements are set to qnan. * If the matrix is not invertible all elements are set to qnan.
* Beware, use (f != f) to check whether a TReal f is qnan. * Beware, use (f != f) to check whether a TReal f is qnan.
*/ */
aiMatrix4x4t& Inverse(); aiMatrix4x4t& Inverse();
TReal Determinant() const; TReal Determinant() const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns true of the matrix is the identity matrix. /** @brief Returns true of the matrix is the identity matrix.
* The check is performed against a not so small epsilon. * The check is performed against a not so small epsilon.
*/ */
inline bool IsIdentity() const; inline bool IsIdentity() const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Decompose a trafo matrix into its original components /** @brief Decompose a trafo matrix into its original components
* @param scaling Receives the output scaling for the x,y,z axes * @param scaling Receives the output scaling for the x,y,z axes
* @param rotation Receives the output rotation as a hamilton * @param rotation Receives the output rotation as a hamilton
* quaternion * quaternion
* @param position Receives the output position for the x,y,z axes * @param position Receives the output position for the x,y,z axes
*/ */
void Decompose (aiVector3t<TReal>& scaling, aiQuaterniont<TReal>& rotation, void Decompose (aiVector3t<TReal>& scaling, aiQuaterniont<TReal>& rotation,
aiVector3t<TReal>& position) const; aiVector3t<TReal>& position) const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Decompose a trafo matrix with no scaling into its /** @brief Decompose a trafo matrix with no scaling into its
* original components * original components
* @param rotation Receives the output rotation as a hamilton * @param rotation Receives the output rotation as a hamilton
* quaternion * quaternion
* @param position Receives the output position for the x,y,z axes * @param position Receives the output position for the x,y,z axes
*/ */
void DecomposeNoScaling (aiQuaterniont<TReal>& rotation, void DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
aiVector3t<TReal>& position) const; aiVector3t<TReal>& position) const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Creates a trafo matrix from a set of euler angles /** @brief Creates a trafo matrix from a set of euler angles
* @param x Rotation angle for the x-axis, in radians * @param x Rotation angle for the x-axis, in radians
* @param y Rotation angle for the y-axis, in radians * @param y Rotation angle for the y-axis, in radians
* @param z Rotation angle for the z-axis, in radians * @param z Rotation angle for the z-axis, in radians
*/ */
aiMatrix4x4t& FromEulerAnglesXYZ(TReal x, TReal y, TReal z); aiMatrix4x4t& FromEulerAnglesXYZ(TReal x, TReal y, TReal z);
aiMatrix4x4t& FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb); aiMatrix4x4t& FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb);
public: public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a rotation matrix for a rotation around the x axis /** @brief Returns a rotation matrix for a rotation around the x axis
* @param a Rotation angle, in radians * @param a Rotation angle, in radians
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix4x4t& RotationX(TReal a, aiMatrix4x4t& out); static aiMatrix4x4t& RotationX(TReal a, aiMatrix4x4t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a rotation matrix for a rotation around the y axis /** @brief Returns a rotation matrix for a rotation around the y axis
* @param a Rotation angle, in radians * @param a Rotation angle, in radians
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix4x4t& RotationY(TReal a, aiMatrix4x4t& out); static aiMatrix4x4t& RotationY(TReal a, aiMatrix4x4t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a rotation matrix for a rotation around the z axis /** @brief Returns a rotation matrix for a rotation around the z axis
* @param a Rotation angle, in radians * @param a Rotation angle, in radians
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix4x4t& RotationZ(TReal a, aiMatrix4x4t& out); static aiMatrix4x4t& RotationZ(TReal a, aiMatrix4x4t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Returns a rotation matrix for a rotation around an arbitrary axis. /** Returns a rotation matrix for a rotation around an arbitrary axis.
* @param a Rotation angle, in radians * @param a Rotation angle, in radians
* @param axis Rotation axis, should be a normalized vector. * @param axis Rotation axis, should be a normalized vector.
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix4x4t& Rotation(TReal a, const aiVector3t<TReal>& axis, static aiMatrix4x4t& Rotation(TReal a, const aiVector3t<TReal>& axis,
aiMatrix4x4t& out); aiMatrix4x4t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a translation matrix /** @brief Returns a translation matrix
* @param v Translation vector * @param v Translation vector
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix4x4t& Translation( const aiVector3t<TReal>& v, aiMatrix4x4t& out); static aiMatrix4x4t& Translation( const aiVector3t<TReal>& v, aiMatrix4x4t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief Returns a scaling matrix /** @brief Returns a scaling matrix
* @param v Scaling vector * @param v Scaling vector
* @param out Receives the output matrix * @param out Receives the output matrix
* @return Reference to the output matrix * @return Reference to the output matrix
*/ */
static aiMatrix4x4t& Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t& out); static aiMatrix4x4t& Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t& out);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** @brief A function for creating a rotation matrix that rotates a /** @brief A function for creating a rotation matrix that rotates a
* vector called "from" into another vector called "to". * vector called "from" into another vector called "to".
* Input : from[3], to[3] which both must be *normalized* non-zero vectors * Input : from[3], to[3] which both must be *normalized* non-zero vectors
* Output: mtx[3][3] -- a 3x3 matrix in colum-major form * Output: mtx[3][3] -- a 3x3 matrix in colum-major form
* Authors: Tomas Möller, John Hughes * Authors: Tomas Möller, John Hughes
* "Efficiently Building a Matrix to Rotate One Vector to Another" * "Efficiently Building a Matrix to Rotate One Vector to Another"
* Journal of Graphics Tools, 4(4):1-4, 1999 * Journal of Graphics Tools, 4(4):1-4, 1999
*/ */
static aiMatrix4x4t& FromToMatrix(const aiVector3t<TReal>& from, static aiMatrix4x4t& FromToMatrix(const aiVector3t<TReal>& from,
const aiVector3t<TReal>& to, aiMatrix4x4t& out); const aiVector3t<TReal>& to, aiMatrix4x4t& out);
public: public:
TReal a1, a2, a3, a4; TReal a1, a2, a3, a4;
TReal b1, b2, b3, b4; TReal b1, b2, b3, b4;
TReal c1, c2, c3, c4; TReal c1, c2, c3, c4;
TReal d1, d2, d3, d4; TReal d1, d2, d3, d4;
} PACK_STRUCT; } PACK_STRUCT;
@ -235,10 +235,10 @@ typedef aiMatrix4x4t<float> aiMatrix4x4;
#else #else
struct aiMatrix4x4 { struct aiMatrix4x4 {
float a1, a2, a3, a4; float a1, a2, a3, a4;
float b1, b2, b3, b4; float b1, b2, b3, b4;
float c1, c2, c3, c4; float c1, c2, c3, c4;
float d1, d2, d3, d4; float d1, d2, d3, d4;
}; };

512
include/assimp/matrix4x4.inl
View File

@ -58,10 +58,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
aiMatrix4x4t<TReal> ::aiMatrix4x4t () : aiMatrix4x4t<TReal> ::aiMatrix4x4t () :
a1(1.0f), a2(), a3(), a4(), a1(1.0f), a2(), a3(), a4(),
b1(), b2(1.0f), b3(), b4(), b1(), b2(1.0f), b3(), b4(),
c1(), c2(), c3(1.0f), c4(), c1(), c2(), c3(1.0f), c4(),
d1(), d2(), d3(), d4(1.0f) d1(), d2(), d3(), d4(1.0f)
{ {
} }
@ -69,13 +69,13 @@ aiMatrix4x4t<TReal> ::aiMatrix4x4t () :
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
aiMatrix4x4t<TReal> ::aiMatrix4x4t (TReal _a1, TReal _a2, TReal _a3, TReal _a4, aiMatrix4x4t<TReal> ::aiMatrix4x4t (TReal _a1, TReal _a2, TReal _a3, TReal _a4,
TReal _b1, TReal _b2, TReal _b3, TReal _b4, TReal _b1, TReal _b2, TReal _b3, TReal _b4,
TReal _c1, TReal _c2, TReal _c3, TReal _c4, TReal _c1, TReal _c2, TReal _c3, TReal _c4,
TReal _d1, TReal _d2, TReal _d3, TReal _d4) : TReal _d1, TReal _d2, TReal _d3, TReal _d4) :
a1(_a1), a2(_a2), a3(_a3), a4(_a4), a1(_a1), a2(_a2), a3(_a3), a4(_a4),
b1(_b1), b2(_b2), b3(_b3), b4(_b4), b1(_b1), b2(_b2), b3(_b3), b4(_b4),
c1(_c1), c2(_c2), c3(_c3), c4(_c4), c1(_c1), c2(_c2), c3(_c3), c4(_c4),
d1(_d1), d2(_d2), d3(_d3), d4(_d4) d1(_d1), d2(_d2), d3(_d3), d4(_d4)
{ {
} }
@ -85,10 +85,10 @@ template <typename TReal>
template <typename TOther> template <typename TOther>
aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const
{ {
return aiMatrix4x4t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),static_cast<TOther>(a4), return aiMatrix4x4t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),static_cast<TOther>(a4),
static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),static_cast<TOther>(b4), static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),static_cast<TOther>(b4),
static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3),static_cast<TOther>(c4), static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3),static_cast<TOther>(c4),
static_cast<TOther>(d1),static_cast<TOther>(d2),static_cast<TOther>(d3),static_cast<TOther>(d4)); static_cast<TOther>(d1),static_cast<TOther>(d2),static_cast<TOther>(d3),static_cast<TOther>(d4));
} }
@ -96,71 +96,71 @@ aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiMatrix3x3t<TReal>& m) inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiMatrix3x3t<TReal>& m)
{ {
a1 = m.a1; a2 = m.a2; a3 = m.a3; a4 = static_cast<TReal>(0.0); a1 = m.a1; a2 = m.a2; a3 = m.a3; a4 = static_cast<TReal>(0.0);
b1 = m.b1; b2 = m.b2; b3 = m.b3; b4 = static_cast<TReal>(0.0); b1 = m.b1; b2 = m.b2; b3 = m.b3; b4 = static_cast<TReal>(0.0);
c1 = m.c1; c2 = m.c2; c3 = m.c3; c4 = static_cast<TReal>(0.0); c1 = m.c1; c2 = m.c2; c3 = m.c3; c4 = static_cast<TReal>(0.0);
d1 = static_cast<TReal>(0.0); d2 = static_cast<TReal>(0.0); d3 = static_cast<TReal>(0.0); d4 = static_cast<TReal>(1.0); d1 = static_cast<TReal>(0.0); d2 = static_cast<TReal>(0.0); d3 = static_cast<TReal>(0.0); d4 = static_cast<TReal>(1.0);
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation, const aiVector3t<TReal>& position) inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation, const aiVector3t<TReal>& position)
{ {
// build a 3x3 rotation matrix // build a 3x3 rotation matrix
aiMatrix3x3t<TReal> m = rotation.GetMatrix(); aiMatrix3x3t<TReal> m = rotation.GetMatrix();
a1 = m.a1 * scaling.x; a1 = m.a1 * scaling.x;
a2 = m.a2 * scaling.x; a2 = m.a2 * scaling.x;
a3 = m.a3 * scaling.x; a3 = m.a3 * scaling.x;
a4 = position.x; a4 = position.x;
b1 = m.b1 * scaling.y; b1 = m.b1 * scaling.y;
b2 = m.b2 * scaling.y; b2 = m.b2 * scaling.y;
b3 = m.b3 * scaling.y; b3 = m.b3 * scaling.y;
b4 = position.y; b4 = position.y;
c1 = m.c1 * scaling.z; c1 = m.c1 * scaling.z;
c2 = m.c2 * scaling.z; c2 = m.c2 * scaling.z;
c3 = m.c3 * scaling.z; c3 = m.c3 * scaling.z;
c4= position.z; c4= position.z;
d1 = static_cast<TReal>(0.0); d1 = static_cast<TReal>(0.0);
d2 = static_cast<TReal>(0.0); d2 = static_cast<TReal>(0.0);
d3 = static_cast<TReal>(0.0); d3 = static_cast<TReal>(0.0);
d4 = static_cast<TReal>(1.0); d4 = static_cast<TReal>(1.0);
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::operator *= (const aiMatrix4x4t<TReal>& m) inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::operator *= (const aiMatrix4x4t<TReal>& m)
{ {
*this = aiMatrix4x4t<TReal>( *this = aiMatrix4x4t<TReal>(
m.a1 * a1 + m.b1 * a2 + m.c1 * a3 + m.d1 * a4, m.a1 * a1 + m.b1 * a2 + m.c1 * a3 + m.d1 * a4,
m.a2 * a1 + m.b2 * a2 + m.c2 * a3 + m.d2 * a4, m.a2 * a1 + m.b2 * a2 + m.c2 * a3 + m.d2 * a4,
m.a3 * a1 + m.b3 * a2 + m.c3 * a3 + m.d3 * 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.a4 * a1 + m.b4 * a2 + m.c4 * a3 + m.d4 * a4,
m.a1 * b1 + m.b1 * b2 + m.c1 * b3 + m.d1 * b4, 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.a2 * b1 + m.b2 * b2 + m.c2 * b3 + m.d2 * b4,
m.a3 * b1 + m.b3 * b2 + m.c3 * b3 + m.d3 * 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.a4 * b1 + m.b4 * b2 + m.c4 * b3 + m.d4 * b4,
m.a1 * c1 + m.b1 * c2 + m.c1 * c3 + m.d1 * c4, 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.a2 * c1 + m.b2 * c2 + m.c2 * c3 + m.d2 * c4,
m.a3 * c1 + m.b3 * c2 + m.c3 * c3 + m.d3 * 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.a4 * c1 + m.b4 * c2 + m.c4 * c3 + m.d4 * c4,
m.a1 * d1 + m.b1 * d2 + m.c1 * d3 + m.d1 * d4, 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.a2 * d1 + m.b2 * d2 + m.c2 * d3 + m.d2 * d4,
m.a3 * d1 + m.b3 * d2 + m.c3 * d3 + m.d3 * 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); m.a4 * d1 + m.b4 * d2 + m.c4 * d3 + m.d4 * d4);
return *this; return *this;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const aiMatrix4x4t<TReal>& m) const inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const aiMatrix4x4t<TReal>& m) const
{ {
aiMatrix4x4t<TReal> temp( *this); aiMatrix4x4t<TReal> temp( *this);
temp *= m; temp *= m;
return temp; return temp;
} }
@ -168,14 +168,14 @@ inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const aiMatrix4x4t<TR
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose() inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose()
{ {
// (TReal&) don't remove, GCC complains cause of packed fields // (TReal&) don't remove, GCC complains cause of packed fields
std::swap( (TReal&)b1, (TReal&)a2); std::swap( (TReal&)b1, (TReal&)a2);
std::swap( (TReal&)c1, (TReal&)a3); std::swap( (TReal&)c1, (TReal&)a3);
std::swap( (TReal&)c2, (TReal&)b3); std::swap( (TReal&)c2, (TReal&)b3);
std::swap( (TReal&)d1, (TReal&)a4); std::swap( (TReal&)d1, (TReal&)a4);
std::swap( (TReal&)d2, (TReal&)b4); std::swap( (TReal&)d2, (TReal&)b4);
std::swap( (TReal&)d3, (TReal&)c4); std::swap( (TReal&)d3, (TReal&)c4);
return *this; return *this;
} }
@ -183,291 +183,291 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose()
template <typename TReal> template <typename TReal>
inline TReal aiMatrix4x4t<TReal>::Determinant() const inline TReal aiMatrix4x4t<TReal>::Determinant() const
{ {
return a1*b2*c3*d4 - a1*b2*c4*d3 + a1*b3*c4*d2 - a1*b3*c2*d4 return a1*b2*c3*d4 - a1*b2*c4*d3 + a1*b3*c4*d2 - a1*b3*c2*d4
+ a1*b4*c2*d3 - a1*b4*c3*d2 - a2*b3*c4*d1 + a2*b3*c1*d4 + a1*b4*c2*d3 - a1*b4*c3*d2 - a2*b3*c4*d1 + a2*b3*c1*d4
- a2*b4*c1*d3 + a2*b4*c3*d1 - a2*b1*c3*d4 + a2*b1*c4*d3 - a2*b4*c1*d3 + a2*b4*c3*d1 - a2*b1*c3*d4 + a2*b1*c4*d3
+ a3*b4*c1*d2 - a3*b4*c2*d1 + a3*b1*c2*d4 - a3*b1*c4*d2 + 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 + 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; - a4*b2*c3*d1 + a4*b2*c1*d3 - a4*b3*c1*d2 + a4*b3*c2*d1;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Inverse() inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Inverse()
{ {
// Compute the reciprocal determinant // Compute the reciprocal determinant
const TReal det = Determinant(); const TReal det = Determinant();
if(det == static_cast<TReal>(0.0)) if(det == static_cast<TReal>(0.0))
{ {
// Matrix not invertible. Setting all elements to nan is not really // Matrix not invertible. Setting all elements to nan is not really
// correct in a mathematical sense but it is easy to debug for the // correct in a mathematical sense but it is easy to debug for the
// programmer. // programmer.
const TReal nan = std::numeric_limits<TReal>::quiet_NaN(); const TReal nan = std::numeric_limits<TReal>::quiet_NaN();
*this = aiMatrix4x4t<TReal>( *this = aiMatrix4x4t<TReal>(
nan,nan,nan,nan, nan,nan,nan,nan,
nan,nan,nan,nan, nan,nan,nan,nan,
nan,nan,nan,nan, nan,nan,nan,nan,
nan,nan,nan,nan); nan,nan,nan,nan);
return *this; return *this;
} }
const TReal invdet = static_cast<TReal>(1.0) / det; const TReal invdet = static_cast<TReal>(1.0) / det;
aiMatrix4x4t<TReal> res; aiMatrix4x4t<TReal> res;
res.a1 = invdet * (b2 * (c3 * d4 - c4 * d3) + b3 * (c4 * d2 - c2 * d4) + b4 * (c2 * d3 - c3 * d2)); 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.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.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.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.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.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.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.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.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.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.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.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.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.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.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)); res.d4 = invdet * (a1 * (b2 * c3 - b3 * c2) + a2 * (b3 * c1 - b1 * c3) + a3 * (b1 * c2 - b2 * c1));
*this = res; *this = res;
return *this; return *this;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) inline TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex)
{ {
// XXX this is UB. Has been for years. The fact that it works now does not make it better. // XXX this is UB. Has been for years. The fact that it works now does not make it better.
return &this->a1 + p_iIndex * 4; return &this->a1 + p_iIndex * 4;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline const TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) const inline const TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) const
{ {
// XXX same // XXX same
return &this->a1 + p_iIndex * 4; return &this->a1 + p_iIndex * 4;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline bool aiMatrix4x4t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const inline bool aiMatrix4x4t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const
{ {
return (a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && a4 == m.a4 && return (a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && a4 == m.a4 &&
b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && b4 == m.b4 && b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && b4 == m.b4 &&
c1 == m.c1 && c2 == m.c2 && c3 == m.c3 && c4 == m.c4 && c1 == m.c1 && c2 == m.c2 && c3 == m.c3 && c4 == m.c4 &&
d1 == m.d1 && d2 == m.d2 && d3 == m.d3 && d4 == m.d4); d1 == m.d1 && d2 == m.d2 && d3 == m.d3 && d4 == m.d4);
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline bool aiMatrix4x4t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const inline bool aiMatrix4x4t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const
{ {
return !(*this == m); return !(*this == m);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
inline bool aiMatrix4x4t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const { inline bool aiMatrix4x4t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
return return
std::abs(a1 - m.a1) <= epsilon && std::abs(a1 - m.a1) <= epsilon &&
std::abs(a2 - m.a2) <= epsilon && std::abs(a2 - m.a2) <= epsilon &&
std::abs(a3 - m.a3) <= epsilon && std::abs(a3 - m.a3) <= epsilon &&
std::abs(a4 - m.a4) <= epsilon && std::abs(a4 - m.a4) <= epsilon &&
std::abs(b1 - m.b1) <= epsilon && std::abs(b1 - m.b1) <= epsilon &&
std::abs(b2 - m.b2) <= epsilon && std::abs(b2 - m.b2) <= epsilon &&
std::abs(b3 - m.b3) <= epsilon && std::abs(b3 - m.b3) <= epsilon &&
std::abs(b4 - m.b4) <= epsilon && std::abs(b4 - m.b4) <= epsilon &&
std::abs(c1 - m.c1) <= epsilon && std::abs(c1 - m.c1) <= epsilon &&
std::abs(c2 - m.c2) <= epsilon && std::abs(c2 - m.c2) <= epsilon &&
std::abs(c3 - m.c3) <= epsilon && std::abs(c3 - m.c3) <= epsilon &&
std::abs(c4 - m.c4) <= epsilon && std::abs(c4 - m.c4) <= epsilon &&
std::abs(d1 - m.d1) <= epsilon && std::abs(d1 - m.d1) <= epsilon &&
std::abs(d2 - m.d2) <= epsilon && std::abs(d2 - m.d2) <= epsilon &&
std::abs(d3 - m.d3) <= epsilon && std::abs(d3 - m.d3) <= epsilon &&
std::abs(d4 - m.d4) <= epsilon; std::abs(d4 - m.d4) <= epsilon;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline void aiMatrix4x4t<TReal>::Decompose (aiVector3t<TReal>& scaling, aiQuaterniont<TReal>& rotation, inline void aiMatrix4x4t<TReal>::Decompose (aiVector3t<TReal>& scaling, aiQuaterniont<TReal>& rotation,
aiVector3t<TReal>& position) const aiVector3t<TReal>& position) const
{ {
const aiMatrix4x4t<TReal>& _this = *this; const aiMatrix4x4t<TReal>& _this = *this;
// extract translation // extract translation
position.x = _this[0][3]; position.x = _this[0][3];
position.y = _this[1][3]; position.y = _this[1][3];
position.z = _this[2][3]; position.z = _this[2][3];
// extract the rows of the matrix // extract the rows of the matrix
aiVector3t<TReal> vRows[3] = { aiVector3t<TReal> vRows[3] = {
aiVector3t<TReal>(_this[0][0],_this[1][0],_this[2][0]), aiVector3t<TReal>(_this[0][0],_this[1][0],_this[2][0]),
aiVector3t<TReal>(_this[0][1],_this[1][1],_this[2][1]), aiVector3t<TReal>(_this[0][1],_this[1][1],_this[2][1]),
aiVector3t<TReal>(_this[0][2],_this[1][2],_this[2][2]) aiVector3t<TReal>(_this[0][2],_this[1][2],_this[2][2])
}; };
// extract the scaling factors // extract the scaling factors
scaling.x = vRows[0].Length(); scaling.x = vRows[0].Length();
scaling.y = vRows[1].Length(); scaling.y = vRows[1].Length();
scaling.z = vRows[2].Length(); scaling.z = vRows[2].Length();
// and the sign of the scaling // and the sign of the scaling
if (Determinant() < 0) { if (Determinant() < 0) {
scaling.x = -scaling.x; scaling.x = -scaling.x;
scaling.y = -scaling.y; scaling.y = -scaling.y;
scaling.z = -scaling.z; scaling.z = -scaling.z;
} }
// and remove all scaling from the matrix // and remove all scaling from the matrix
if(scaling.x) if(scaling.x)
{ {
vRows[0] /= scaling.x; vRows[0] /= scaling.x;
} }
if(scaling.y) if(scaling.y)
{ {
vRows[1] /= scaling.y; vRows[1] /= scaling.y;
} }
if(scaling.z) if(scaling.z)
{ {
vRows[2] /= scaling.z; vRows[2] /= scaling.z;
} }
// build a 3x3 rotation matrix // build a 3x3 rotation matrix
aiMatrix3x3t<TReal> m(vRows[0].x,vRows[1].x,vRows[2].x, aiMatrix3x3t<TReal> m(vRows[0].x,vRows[1].x,vRows[2].x,
vRows[0].y,vRows[1].y,vRows[2].y, vRows[0].y,vRows[1].y,vRows[2].y,
vRows[0].z,vRows[1].z,vRows[2].z); vRows[0].z,vRows[1].z,vRows[2].z);
// and generate the rotation quaternion from it // and generate the rotation quaternion from it
rotation = aiQuaterniont<TReal>(m); rotation = aiQuaterniont<TReal>(m);
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline void aiMatrix4x4t<TReal>::DecomposeNoScaling (aiQuaterniont<TReal>& rotation, inline void aiMatrix4x4t<TReal>::DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
aiVector3t<TReal>& position) const aiVector3t<TReal>& position) const
{ {
const aiMatrix4x4t<TReal>& _this = *this; const aiMatrix4x4t<TReal>& _this = *this;
// extract translation // extract translation
position.x = _this[0][3]; position.x = _this[0][3];
position.y = _this[1][3]; position.y = _this[1][3];
position.z = _this[2][3]; position.z = _this[2][3];
// extract rotation // extract rotation
rotation = aiQuaterniont<TReal>((aiMatrix3x3t<TReal>)_this); rotation = aiQuaterniont<TReal>((aiMatrix3x3t<TReal>)_this);
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb) inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb)
{ {
return FromEulerAnglesXYZ(blubb.x,blubb.y,blubb.z); return FromEulerAnglesXYZ(blubb.x,blubb.y,blubb.z);
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(TReal x, TReal y, TReal z) inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(TReal x, TReal y, TReal z)
{ {
aiMatrix4x4t<TReal>& _this = *this; aiMatrix4x4t<TReal>& _this = *this;
TReal cr = std::cos( x ); TReal cr = std::cos( x );
TReal sr = std::sin( x ); TReal sr = std::sin( x );
TReal cp = std::cos( y ); TReal cp = std::cos( y );
TReal sp = std::sin( y ); TReal sp = std::sin( y );
TReal cy = std::cos( z ); TReal cy = std::cos( z );
TReal sy = std::sin( z ); TReal sy = std::sin( z );
_this.a1 = cp*cy ; _this.a1 = cp*cy ;
_this.a2 = cp*sy; _this.a2 = cp*sy;
_this.a3 = -sp ; _this.a3 = -sp ;
TReal srsp = sr*sp; TReal srsp = sr*sp;
TReal crsp = cr*sp; TReal crsp = cr*sp;
_this.b1 = srsp*cy-cr*sy ; _this.b1 = srsp*cy-cr*sy ;
_this.b2 = srsp*sy+cr*cy ; _this.b2 = srsp*sy+cr*cy ;
_this.b3 = sr*cp ; _this.b3 = sr*cp ;
_this.c1 = crsp*cy+sr*sy ; _this.c1 = crsp*cy+sr*sy ;
_this.c2 = crsp*sy-sr*cy ; _this.c2 = crsp*sy-sr*cy ;
_this.c3 = cr*cp ; _this.c3 = cr*cp ;
return *this; return *this;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline bool aiMatrix4x4t<TReal>::IsIdentity() const inline bool aiMatrix4x4t<TReal>::IsIdentity() const
{ {
// Use a small epsilon to solve floating-point inaccuracies // Use a small epsilon to solve floating-point inaccuracies
const static TReal epsilon = 10e-3f; const static TReal epsilon = 10e-3f;
return (a2 <= epsilon && a2 >= -epsilon && return (a2 <= epsilon && a2 >= -epsilon &&
a3 <= epsilon && a3 >= -epsilon && a3 <= epsilon && a3 >= -epsilon &&
a4 <= epsilon && a4 >= -epsilon && a4 <= epsilon && a4 >= -epsilon &&
b1 <= epsilon && b1 >= -epsilon && b1 <= epsilon && b1 >= -epsilon &&
b3 <= epsilon && b3 >= -epsilon && b3 <= epsilon && b3 >= -epsilon &&
b4 <= epsilon && b4 >= -epsilon && b4 <= epsilon && b4 >= -epsilon &&
c1 <= epsilon && c1 >= -epsilon && c1 <= epsilon && c1 >= -epsilon &&
c2 <= epsilon && c2 >= -epsilon && c2 <= epsilon && c2 >= -epsilon &&
c4 <= epsilon && c4 >= -epsilon && c4 <= epsilon && c4 >= -epsilon &&
d1 <= epsilon && d1 >= -epsilon && d1 <= epsilon && d1 >= -epsilon &&
d2 <= epsilon && d2 >= -epsilon && d2 <= epsilon && d2 >= -epsilon &&
d3 <= epsilon && d3 >= -epsilon && d3 <= epsilon && d3 >= -epsilon &&
a1 <= 1.f+epsilon && a1 >= 1.f-epsilon && a1 <= 1.f+epsilon && a1 >= 1.f-epsilon &&
b2 <= 1.f+epsilon && b2 >= 1.f-epsilon && b2 <= 1.f+epsilon && b2 >= 1.f-epsilon &&
c3 <= 1.f+epsilon && c3 >= 1.f-epsilon && c3 <= 1.f+epsilon && c3 >= 1.f-epsilon &&
d4 <= 1.f+epsilon && d4 >= 1.f-epsilon); d4 <= 1.f+epsilon && d4 >= 1.f-epsilon);
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationX(TReal a, aiMatrix4x4t<TReal>& out) inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationX(TReal a, aiMatrix4x4t<TReal>& out)
{ {
/* /*
| 1 0 0 0 | | 1 0 0 0 |
M = | 0 cos(A) -sin(A) 0 | M = | 0 cos(A) -sin(A) 0 |
| 0 sin(A) cos(A) 0 | | 0 sin(A) cos(A) 0 |
| 0 0 0 1 | */ | 0 0 0 1 | */
out = aiMatrix4x4t<TReal>(); out = aiMatrix4x4t<TReal>();
out.b2 = out.c3 = std::cos(a); out.b2 = out.c3 = std::cos(a);
out.b3 = -(out.c2 = std::sin(a)); out.b3 = -(out.c2 = std::sin(a));
return out; return out;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationY(TReal a, aiMatrix4x4t<TReal>& out) inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationY(TReal a, aiMatrix4x4t<TReal>& out)
{ {
/* /*
| cos(A) 0 sin(A) 0 | | cos(A) 0 sin(A) 0 |
M = | 0 1 0 0 | M = | 0 1 0 0 |
| -sin(A) 0 cos(A) 0 | | -sin(A) 0 cos(A) 0 |
| 0 0 0 1 | | 0 0 0 1 |
*/ */
out = aiMatrix4x4t<TReal>(); out = aiMatrix4x4t<TReal>();
out.a1 = out.c3 = std::cos(a); out.a1 = out.c3 = std::cos(a);
out.c1 = -(out.a3 = std::sin(a)); out.c1 = -(out.a3 = std::sin(a));
return out; return out;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationZ(TReal a, aiMatrix4x4t<TReal>& out) inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationZ(TReal a, aiMatrix4x4t<TReal>& out)
{ {
/* /*
| cos(A) -sin(A) 0 0 | | cos(A) -sin(A) 0 0 |
M = | sin(A) cos(A) 0 0 | M = | sin(A) cos(A) 0 0 |
| 0 0 1 0 | | 0 0 1 0 |
| 0 0 0 1 | */ | 0 0 0 1 | */
out = aiMatrix4x4t<TReal>(); out = aiMatrix4x4t<TReal>();
out.a1 = out.b2 = std::cos(a); out.a1 = out.b2 = std::cos(a);
out.a2 = -(out.b1 = std::sin(a)); out.a2 = -(out.b1 = std::sin(a));
return out; return out;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
@ -493,22 +493,22 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Rotation( TReal a, const aiVect
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Translation( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out) inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Translation( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out)
{ {
out = aiMatrix4x4t<TReal>(); out = aiMatrix4x4t<TReal>();
out.a4 = v.x; out.a4 = v.x;
out.b4 = v.y; out.b4 = v.y;
out.c4 = v.z; out.c4 = v.z;
return out; return out;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out) inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out)
{ {
out = aiMatrix4x4t<TReal>(); out = aiMatrix4x4t<TReal>();
out.a1 = v.x; out.a1 = v.x;
out.b2 = v.y; out.b2 = v.y;
out.c3 = v.z; out.c3 = v.z;
return out; return out;
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
@ -523,12 +523,12 @@ inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromToMatrix(const aiVector3t<TReal>& from, inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
const aiVector3t<TReal>& to, aiMatrix4x4t<TReal>& mtx) const aiVector3t<TReal>& to, aiMatrix4x4t<TReal>& mtx)
{ {
aiMatrix3x3t<TReal> m3; aiMatrix3x3t<TReal> m3;
aiMatrix3x3t<TReal>::FromToMatrix(from,to,m3); aiMatrix3x3t<TReal>::FromToMatrix(from,to,m3);
mtx = aiMatrix4x4t<TReal>(m3); mtx = aiMatrix4x4t<TReal>(m3);
return mtx; return mtx;
} }
#endif // __cplusplus #endif // __cplusplus

876
include/assimp/mesh.h
View File

File diff suppressed because it is too large Load Diff

192
include/assimp/metadata.h
View File

@ -63,15 +63,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
typedef enum aiMetadataType typedef enum aiMetadataType
{ {
AI_BOOL = 0, AI_BOOL = 0,
AI_INT = 1, AI_INT = 1,
AI_UINT64 = 2, AI_UINT64 = 2,
AI_FLOAT = 3, AI_FLOAT = 3,
AI_AISTRING = 4, AI_AISTRING = 4,
AI_AIVECTOR3D = 5, AI_AIVECTOR3D = 5,
#ifndef SWIG #ifndef SWIG
FORCE_32BIT = INT_MAX FORCE_32BIT = INT_MAX
#endif #endif
} aiMetadataType; } aiMetadataType;
@ -86,8 +86,8 @@ typedef enum aiMetadataType
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
struct aiMetadataEntry struct aiMetadataEntry
{ {
aiMetadataType mType; aiMetadataType mType;
void* mData; void* mData;
}; };
@ -125,117 +125,117 @@ inline aiMetadataType GetAiType( aiVector3D ) { return AI_AIVECTOR3D; }
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
struct aiMetadata struct aiMetadata
{ {
/** Length of the mKeys and mValues arrays, respectively */ /** Length of the mKeys and mValues arrays, respectively */
unsigned int mNumProperties; unsigned int mNumProperties;
/** Arrays of keys, may not be NULL. Entries in this array may not be NULL as well. */ /** Arrays of keys, may not be NULL. Entries in this array may not be NULL as well. */
C_STRUCT aiString* mKeys; C_STRUCT aiString* mKeys;
/** Arrays of values, may not be NULL. Entries in this array may be NULL if the /** Arrays of values, may not be NULL. Entries in this array may be NULL if the
* corresponding property key has no assigned value. */ * corresponding property key has no assigned value. */
C_STRUCT aiMetadataEntry* mValues; C_STRUCT aiMetadataEntry* mValues;
#ifdef __cplusplus #ifdef __cplusplus
/** Constructor */ /** Constructor */
aiMetadata() aiMetadata()
// set all members to zero by default // set all members to zero by default
: mNumProperties(0) : mNumProperties(0)
, mKeys(NULL) , mKeys(NULL)
, mValues(NULL) , mValues(NULL)
{} {}
/** Destructor */ /** Destructor */
~aiMetadata() ~aiMetadata()
{ {
delete[] mKeys; delete[] mKeys;
mKeys = NULL; mKeys = NULL;
if (mValues) if (mValues)
{ {
// Delete each metadata entry // Delete each metadata entry
for (unsigned i=0; i<mNumProperties; ++i) for (unsigned i=0; i<mNumProperties; ++i)
{ {
void* data = mValues[i].mData; void* data = mValues[i].mData;
switch (mValues[i].mType) switch (mValues[i].mType)
{ {
case AI_BOOL: case AI_BOOL:
delete static_cast<bool*>(data); delete static_cast<bool*>(data);
break; break;
case AI_INT: case AI_INT:
delete static_cast<int*>(data); delete static_cast<int*>(data);
break; break;
case AI_UINT64: case AI_UINT64:
delete static_cast<uint64_t*>(data); delete static_cast<uint64_t*>(data);
break; break;
case AI_FLOAT: case AI_FLOAT:
delete static_cast<float*>(data); delete static_cast<float*>(data);
break; break;
case AI_AISTRING: case AI_AISTRING:
delete static_cast<aiString*>(data); delete static_cast<aiString*>(data);
break; break;
case AI_AIVECTOR3D: case AI_AIVECTOR3D:
delete static_cast<aiVector3D*>(data); delete static_cast<aiVector3D*>(data);
break; break;
default: default:
assert(false); assert(false);
break; break;
} }
} }
// Delete the metadata array // Delete the metadata array
delete [] mValues; delete [] mValues;
mValues = NULL; mValues = NULL;
} }
} }
template<typename T> template<typename T>
inline void Set( unsigned index, const std::string& key, const T& value ) inline void Set( unsigned index, const std::string& key, const T& value )
{ {
// In range assertion // In range assertion
assert(index < mNumProperties); assert(index < mNumProperties);
// Set metadata key // Set metadata key
mKeys[index] = key; mKeys[index] = key;
// Set metadata type // Set metadata type
mValues[index].mType = GetAiType(value); mValues[index].mType = GetAiType(value);
// Copy the given value to the dynamic storage // Copy the given value to the dynamic storage
mValues[index].mData = new T(value); mValues[index].mData = new T(value);
} }
template<typename T> template<typename T>
inline bool Get( unsigned index, T& value ) inline bool Get( unsigned index, T& value )
{ {
// In range assertion // In range assertion
assert(index < mNumProperties); assert(index < mNumProperties);
// Return false if the output data type does // Return false if the output data type does
// not match the found value's data type // not match the found value's data type
if ( GetAiType( value ) != mValues[ index ].mType ) { if ( GetAiType( value ) != mValues[ index ].mType ) {
return false; return false;
} }
// Otherwise, output the found value and // Otherwise, output the found value and
// return true // return true
value = *static_cast<T*>(mValues[index].mData); value = *static_cast<T*>(mValues[index].mData);
return true; return true;
} }
template<typename T> template<typename T>
inline bool Get( const aiString& key, T& value ) inline bool Get( const aiString& key, T& value )
{ {
// Search for the given key // Search for the given key
for (unsigned i=0; i<mNumProperties; ++i) for (unsigned i=0; i<mNumProperties; ++i)
if (mKeys[i]==key) if (mKeys[i]==key)
return Get(i, value); return Get(i, value);
return false; return false;
} }
template<typename T> template<typename T>
inline bool Get( const std::string& key, T& value ) { inline bool Get( const std::string& key, T& value ) {
return Get(aiString(key), value); return Get(aiString(key), value);
} }

948
include/assimp/postprocess.h
View File

@ -65,469 +65,469 @@ extern "C" {
enum aiPostProcessSteps enum aiPostProcessSteps
{ {
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
/** <hr>Calculates the tangents and bitangents for the imported meshes. /** <hr>Calculates the tangents and bitangents for the imported meshes.
* *
* Does nothing if a mesh does not have normals. You might want this post * 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 * processing step to be executed if you plan to use tangent space calculations
* such as normal mapping applied to the meshes. There's an importer property, * such as normal mapping applied to the meshes. There's an importer property,
* <tt>#AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE</tt>, which allows you to specify * <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 * a maximum smoothing angle for the algorithm. However, usually you'll
* want to leave it at the default value. * want to leave it at the default value.
*/ */
aiProcess_CalcTangentSpace = 0x1, aiProcess_CalcTangentSpace = 0x1,
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
/** <hr>Identifies and joins identical vertex data sets within all /** <hr>Identifies and joins identical vertex data sets within all
* imported meshes. * imported meshes.
* *
* After this step is run, each mesh contains unique vertices, * After this step is run, each mesh contains unique vertices,
* so a vertex may be used by multiple faces. You usually want * so a vertex may be used by multiple faces. You usually want
* to use this post processing step. If your application deals with * to use this post processing step. If your application deals with
* indexed geometry, this step is compulsory or you'll just waste rendering * 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 * 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. * more than one face and <b>no index buffer is required</b> for rendering.
*/ */
aiProcess_JoinIdenticalVertices = 0x2, aiProcess_JoinIdenticalVertices = 0x2,
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
/** <hr>Converts all the imported data to a left-handed coordinate space. /** <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 * By default the data is returned in a right-handed coordinate space (which
* OpenGL prefers). In this space, +X points to the right, * OpenGL prefers). In this space, +X points to the right,
* +Z points towards the viewer, and +Y points upwards. In the DirectX * +Z points towards the viewer, and +Y points upwards. In the DirectX
* coordinate space +X points to the right, +Y points upwards, and +Z points * coordinate space +X points to the right, +Y points upwards, and +Z points
* away from the viewer. * 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 faces with more than 3 indices into
* 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
* importer property, <tt>#AI_CONFIG_PP_RVC_FLAGS</tt>. This is quite useful
* if you don't need all parts of the output structure. Vertex colors
* are rarely used today for example... Calling this step to remove unneeded
* data from the pipeline as early as possible results in increased
* performance and a more 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, and it has per-face vertex colors. Vertex positions can't be
* shared, thus the #aiProcess_JoinIdenticalVertices step fails to
* optimize the data because of 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 optimizations.
*/
aiProcess_RemoveComponent = 0x10,
// -------------------------------------------------------------------------
/** <hr>Generates normals for all faces of all meshes.
*
* This is ignored if normals are already there at the time 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
* forces 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 this flag
* is evaluated. Model importers try to load them from the source file, so
* they're usually already there.
*
* This flag may not be specified together with
* #aiProcess_GenNormals. There's a importer property,
* <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 'hard' seam between two faces.
* Using a decent angle here (e.g. 80 degrees) results in very good visual
* appearance.
*/
aiProcess_GenSmoothNormals = 0x40,
// -------------------------------------------------------------------------
/** <hr>Splits large meshes into smaller sub-meshes.
*
* This is quite useful for real-time rendering, where the number of triangles
* which can be maximally processed in a single draw-call is 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>
* importer properties. 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 only if there's
* something 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 still contains nodes, however there is only a
* root node with children, each one referencing only one mesh,
* and 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 the maximum 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
* config.h), but you can use the <tt>#AI_CONFIG_PP_LBW_MAX_WEIGHTS</tt> importer
* property 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 to 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 that you capture Assimp's log output if you use this flag,
* so you can easily find out what's wrong if a file fails the
* validation. The validator is quite strict and will find *all*
* inconsistencies in the data structure... It is recommended that plugin
* developers 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. Its 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://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 to you. The <tt>#AI_CONFIG_PP_ICL_PTCACHE_SIZE</tt>
* importer property 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 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 (e.g. the material name).
* 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> importer property.
*/
aiProcess_RemoveRedundantMaterials = 0x1000,
// -------------------------------------------------------------------------
/** <hr>This step tries to determine which meshes have normal vectors
* that are facing inwards and inverts them.
*
* 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 sub-meshes.
*
* 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> importer property 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 degenerate primitives and
* converts them to proper lines or points.
*
* A face is 'degenerate' if one or more of its points are identical.
* To have the degenerate stuff not only detected and collapsed but
* removed, try one of the following procedures:
* <br><b>1.</b> (if you support lines and 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> importer property to
* 1. This will cause the step to remove degenerate 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 and 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> importer property to
* @code aiPrimitiveType_POINTS | aiPrimitiveType_LINES
* @endcode to cause SortByPType to reject point
* and line meshes from the scene.
* </li>
* </ul>
* @note Degenerate 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, and some exporters bypass the
* format specification and write them as degenerate triangles 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 that 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
* modelling app compute the UV channels - 3ds max, Maya, Blender,
* LightWave, and Modo do this for example.
*
* @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 into stand-alone vtexture coordinate channels.
*
* 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 a new (pre-transformed) UV channel
* which replaces 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 real-time apps by * You'll probably want to consider this flag if you use Direct3D for
* transforming texture coordinates at vertex shader stage with a 3x3 * rendering. The #aiProcess_ConvertToLeftHanded flag supersedes this
* (homogenous) transformation matrix. * setting and bundles all conversions typically required for D3D-based
*/ * applications.
aiProcess_TransformUVCoords = 0x80000, */
aiProcess_MakeLeftHanded = 0x4,
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
/** <hr>This step searches for duplicate meshes and replaces them /** <hr>Triangulates all faces of all meshes.
* with references to the first mesh. *
* * By default the imported mesh data might contain faces with more than 3
* This step takes a while, so don't use it if speed is a concern. * indices. For rendering you'll usually want all faces to be triangles.
* Its main purpose is to workaround the fact that many export * This post processing step splits up faces with more than 3 indices into
* file formats don't support instanced meshes, so exporters need to * triangles. Line and point primitives are *not* modified! If you want
* duplicate meshes. This step removes the duplicates again. Please * 'triangles only' with no other kinds of primitives, try the following
* note that Assimp does not currently support per-node material * solution:
* assignment to meshes, which means that identical meshes with * <ul>
* different materials are currently *not* joined, although this is * <li>Specify both #aiProcess_Triangulate and #aiProcess_SortByPType </li>
* planned for future versions. * <li>Ignore all point and line meshes when you process assimp's output</li>
*/ * </ul>
aiProcess_FindInstances = 0x100000, */
aiProcess_Triangulate = 0x8,
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
/** <hr>A postprocessing step to reduce the number of meshes. /** <hr>Removes some parts of the data structure (animations, materials,
* * light sources, cameras, textures, vertex components).
* This will, in fact, reduce the number of draw calls. *
* * The components to be removed are specified in a separate
* This is a very effective optimization and is recommended to be used * importer property, <tt>#AI_CONFIG_PP_RVC_FLAGS</tt>. This is quite useful
* together with #aiProcess_OptimizeGraph, if possible. The flag is fully * if you don't need all parts of the output structure. Vertex colors
* compatible with both #aiProcess_SplitLargeMeshes and #aiProcess_SortByPType. * are rarely used today for example... Calling this step to remove unneeded
*/ * data from the pipeline as early as possible results in increased
aiProcess_OptimizeMeshes = 0x200000, * performance and a more 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, and it has per-face vertex colors. Vertex positions can't be
* shared, thus the #aiProcess_JoinIdenticalVertices step fails to
* optimize the data because of 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 optimizations.
*/
aiProcess_RemoveComponent = 0x10,
// -------------------------------------------------------------------------
/** <hr>Generates normals for all faces of all meshes.
*
* This is ignored if normals are already there at the time 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
* forces 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 this flag
* is evaluated. Model importers try to load them from the source file, so
* they're usually already there.
*
* This flag may not be specified together with
* #aiProcess_GenNormals. There's a importer property,
* <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 'hard' seam between two faces.
* Using a decent angle here (e.g. 80 degrees) results in very good visual
* appearance.
*/
aiProcess_GenSmoothNormals = 0x40,
// -------------------------------------------------------------------------
/** <hr>Splits large meshes into smaller sub-meshes.
*
* This is quite useful for real-time rendering, where the number of triangles
* which can be maximally processed in a single draw-call is 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>
* importer properties. 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 only if there's
* something 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 still contains nodes, however there is only a
* root node with children, each one referencing only one mesh,
* and 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 the maximum 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
* config.h), but you can use the <tt>#AI_CONFIG_PP_LBW_MAX_WEIGHTS</tt> importer
* property 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 to 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 that you capture Assimp's log output if you use this flag,
* so you can easily find out what's wrong if a file fails the
* validation. The validator is quite strict and will find *all*
* inconsistencies in the data structure... It is recommended that plugin
* developers 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. Its 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://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 to you. The <tt>#AI_CONFIG_PP_ICL_PTCACHE_SIZE</tt>
* importer property 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 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 (e.g. the material name).
* 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> importer property.
*/
aiProcess_RemoveRedundantMaterials = 0x1000,
// -------------------------------------------------------------------------
/** <hr>This step tries to determine which meshes have normal vectors
* that are facing inwards and inverts them.
*
* 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 sub-meshes.
*
* 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> importer property 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 degenerate primitives and
* converts them to proper lines or points.
*
* A face is 'degenerate' if one or more of its points are identical.
* To have the degenerate stuff not only detected and collapsed but
* removed, try one of the following procedures:
* <br><b>1.</b> (if you support lines and 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> importer property to
* 1. This will cause the step to remove degenerate 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 and 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> importer property to
* @code aiPrimitiveType_POINTS | aiPrimitiveType_LINES
* @endcode to cause SortByPType to reject point
* and line meshes from the scene.
* </li>
* </ul>
* @note Degenerate 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, and some exporters bypass the
* format specification and write them as degenerate triangles 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 that 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
* modelling app compute the UV channels - 3ds max, Maya, Blender,
* LightWave, and Modo do this for example.
*
* @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 into stand-alone vtexture coordinate channels.
*
* 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 a new (pre-transformed) UV channel
* which replaces 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 real-time 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 them
* with references to the first mesh.
*
* This step takes a while, so don't use it if speed is a concern.
* Its main purpose is to workaround the fact 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 not currently support per-node material
* assignment to meshes, which means that identical meshes with
* different 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.
*
* This will, in fact, reduce the number of draw calls.
*
* 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. /** <hr>A postprocessing step to optimize the scene hierarchy.
* *
* Nodes without animations, bones, lights or cameras assigned are * Nodes without animations, bones, lights or cameras assigned are
* collapsed and joined. * collapsed and joined.
* *
* Node names can be lost during this step. If you use special 'tag nodes' * Node names can be lost during this step. If you use special 'tag nodes'
* to pass additional information through your content pipeline, use the * to pass additional information through your content pipeline, use the
* <tt>#AI_CONFIG_PP_OG_EXCLUDE_LIST</tt> importer property to specify a * <tt>#AI_CONFIG_PP_OG_EXCLUDE_LIST</tt> importer property to specify a
* list of node names you want to be kept. Nodes matching one of the names * list of node names you want to be kept. Nodes matching one of the names
* in this list won't be touched or modified. * in this list won't be touched or modified.
* *
* Use this flag with caution. Most simple files will be collapsed to a * Use this flag with caution. Most simple files will be collapsed to a
* single node, so complex hierarchies are usually completely lost. This is not * single node, so complex hierarchies are usually completely lost. This is not
* useful for editor environments, but probably a very effective * useful for editor environments, but probably a very effective
* optimization if you just want to get the model data, convert it to your * optimization if you just want to get the model data, convert it to your
* own format, and render it as fast as possible. * own format, and render it as fast as possible.
* *
* This flag is designed to be used with #aiProcess_OptimizeMeshes for best * This flag is designed to be used with #aiProcess_OptimizeMeshes for best
* results. * results.
* *
* @note 'Crappy' scenes with thousands of extremely small meshes packed * @note 'Crappy' scenes with thousands of extremely small meshes packed
* in deeply nested nodes exist for almost all file formats. * in deeply nested nodes exist for almost all file formats.
* #aiProcess_OptimizeMeshes in combination with #aiProcess_OptimizeGraph * #aiProcess_OptimizeMeshes in combination with #aiProcess_OptimizeGraph
* usually fixes them all and makes them renderable. * usually fixes them all and makes them renderable.
*/ */
aiProcess_OptimizeGraph = 0x400000, aiProcess_OptimizeGraph = 0x400000,
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
/** <hr>This step flips all UV coordinates along the y-axis and adjusts /** <hr>This step flips all UV coordinates along the y-axis and adjusts
* material settings and bitangents accordingly. * material settings and bitangents accordingly.
* *
* <b>Output UV coordinate system:</b> * <b>Output UV coordinate system:</b>
* @code * @code
* 0y|0y ---------- 1x|0y * 0y|0y ---------- 1x|0y
* | | * | |
* | | * | |
* | | * | |
* 0x|1y ---------- 1x|1y * 0x|1y ---------- 1x|1y
* @endcode * @endcode
* *
* You'll probably want to consider this flag if you use Direct3D for * You'll probably want to consider this flag if you use Direct3D for
* rendering. The #aiProcess_ConvertToLeftHanded flag supersedes this * rendering. The #aiProcess_ConvertToLeftHanded flag supersedes this
* setting and bundles all conversions typically required for D3D-based * setting and bundles all conversions typically required for D3D-based
* applications. * applications.
*/
aiProcess_FlipUVs = 0x800000,
// -------------------------------------------------------------------------
/** <hr>This step adjusts the output face winding order to be CW.
*
* The default face winding order is counter clockwise (CCW).
*
* <b>Output face order:</b>
* @code
* x2
*
* x0
* x1
* @endcode
*/
aiProcess_FlipWindingOrder = 0x1000000,
// -------------------------------------------------------------------------
/** <hr>This step splits meshes with many bones into sub-meshes so that each
* su-bmesh has fewer or as many bones as a given limit.
*/ */
aiProcess_SplitByBoneCount = 0x2000000, aiProcess_FlipUVs = 0x800000,
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
/** <hr>This step removes bones losslessly or according to some threshold. /** <hr>This step adjusts the output face winding order to be CW.
* *
* In some cases (i.e. formats that require it) exporters are forced to * The default face winding order is counter clockwise (CCW).
* assign dummy bone weights to otherwise static meshes assigned to *
* animated meshes. Full, weight-based skinning is expensive while * <b>Output face order:</b>
* animating nodes is extremely cheap, so this step is offered to clean up * @code
* the data in that regard. * x2
* *
* Use <tt>#AI_CONFIG_PP_DB_THRESHOLD</tt> to control this. * x0
* Use <tt>#AI_CONFIG_PP_DB_ALL_OR_NONE</tt> if you want bones removed if and * x1
* only if all bones within the scene qualify for removal. * @endcode
*/ */
aiProcess_Debone = 0x4000000 aiProcess_FlipWindingOrder = 0x1000000,
// aiProcess_GenEntityMeshes = 0x100000, // -------------------------------------------------------------------------
// aiProcess_OptimizeAnimations = 0x200000 /** <hr>This step splits meshes with many bones into sub-meshes so that each
// aiProcess_FixTexturePaths = 0x200000 * su-bmesh has fewer or as many bones as a given limit.
*/
aiProcess_SplitByBoneCount = 0x2000000,
// -------------------------------------------------------------------------
/** <hr>This step removes bones losslessly or according to some threshold.
*
* In some cases (i.e. formats that require it) exporters are forced to
* assign dummy bone weights to otherwise static meshes assigned to
* animated meshes. Full, weight-based skinning is expensive while
* animating nodes is extremely cheap, so this step is offered to clean up
* the data in that regard.
*
* Use <tt>#AI_CONFIG_PP_DB_THRESHOLD</tt> to control this.
* Use <tt>#AI_CONFIG_PP_DB_ALL_OR_NONE</tt> if you want bones removed if and
* only if all bones within the scene qualify for removal.
*/
aiProcess_Debone = 0x4000000
// aiProcess_GenEntityMeshes = 0x100000,
// aiProcess_OptimizeAnimations = 0x200000
// aiProcess_FixTexturePaths = 0x200000
}; };
@ -543,10 +543,10 @@ enum aiPostProcessSteps
* @deprecated * @deprecated
*/ */
#define aiProcess_ConvertToLeftHanded ( \ #define aiProcess_ConvertToLeftHanded ( \
aiProcess_MakeLeftHanded | \ aiProcess_MakeLeftHanded | \
aiProcess_FlipUVs | \ aiProcess_FlipUVs | \
aiProcess_FlipWindingOrder | \ aiProcess_FlipWindingOrder | \
0 ) 0 )
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
@ -564,13 +564,13 @@ enum aiPostProcessSteps
* use for you so it might be better to not specify them. * use for you so it might be better to not specify them.
*/ */
#define aiProcessPreset_TargetRealtime_Fast ( \ #define aiProcessPreset_TargetRealtime_Fast ( \
aiProcess_CalcTangentSpace | \ aiProcess_CalcTangentSpace | \
aiProcess_GenNormals | \ aiProcess_GenNormals | \
aiProcess_JoinIdenticalVertices | \ aiProcess_JoinIdenticalVertices | \
aiProcess_Triangulate | \ aiProcess_Triangulate | \
aiProcess_GenUVCoords | \ aiProcess_GenUVCoords | \
aiProcess_SortByPType | \ aiProcess_SortByPType | \
0 ) 0 )
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
/** @def aiProcessPreset_TargetRealtime_Quality /** @def aiProcessPreset_TargetRealtime_Quality
@ -589,19 +589,19 @@ enum aiPostProcessSteps
* of use for you so it might be better to not specify them. * of use for you so it might be better to not specify them.
*/ */
#define aiProcessPreset_TargetRealtime_Quality ( \ #define aiProcessPreset_TargetRealtime_Quality ( \
aiProcess_CalcTangentSpace | \ aiProcess_CalcTangentSpace | \
aiProcess_GenSmoothNormals | \ aiProcess_GenSmoothNormals | \
aiProcess_JoinIdenticalVertices | \ aiProcess_JoinIdenticalVertices | \
aiProcess_ImproveCacheLocality | \ aiProcess_ImproveCacheLocality | \
aiProcess_LimitBoneWeights | \ aiProcess_LimitBoneWeights | \
aiProcess_RemoveRedundantMaterials | \ aiProcess_RemoveRedundantMaterials | \
aiProcess_SplitLargeMeshes | \ aiProcess_SplitLargeMeshes | \
aiProcess_Triangulate | \ aiProcess_Triangulate | \
aiProcess_GenUVCoords | \ aiProcess_GenUVCoords | \
aiProcess_SortByPType | \ aiProcess_SortByPType | \
aiProcess_FindDegenerates | \ aiProcess_FindDegenerates | \
aiProcess_FindInvalidData | \ aiProcess_FindInvalidData | \
0 ) 0 )
// --------------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------
/** @def aiProcessPreset_TargetRealtime_MaxQuality /** @def aiProcessPreset_TargetRealtime_MaxQuality
@ -619,11 +619,11 @@ enum aiPostProcessSteps
* of use for you so it might be better to not specify them. * of use for you so it might be better to not specify them.
*/ */
#define aiProcessPreset_TargetRealtime_MaxQuality ( \ #define aiProcessPreset_TargetRealtime_MaxQuality ( \
aiProcessPreset_TargetRealtime_Quality | \ aiProcessPreset_TargetRealtime_Quality | \
aiProcess_FindInstances | \ aiProcess_FindInstances | \
aiProcess_ValidateDataStructure | \ aiProcess_ValidateDataStructure | \
aiProcess_OptimizeMeshes | \ aiProcess_OptimizeMeshes | \
0 ) 0 )
#ifdef __cplusplus #ifdef __cplusplus

70
include/assimp/quaternion.h
View File

@ -55,61 +55,61 @@ template <typename TReal>
class aiQuaterniont class aiQuaterniont
{ {
public: public:
aiQuaterniont() : w(1.0), x(), y(), z() {} aiQuaterniont() : w(1.0), x(), y(), z() {}
aiQuaterniont(TReal pw, TReal px, TReal py, TReal pz) aiQuaterniont(TReal pw, TReal px, TReal py, TReal pz)
: w(pw), x(px), y(py), z(pz) {} : w(pw), x(px), y(py), z(pz) {}
/** Construct from rotation matrix. Result is undefined if the matrix is not orthonormal. */ /** Construct from rotation matrix. Result is undefined if the matrix is not orthonormal. */
aiQuaterniont( const aiMatrix3x3t<TReal>& pRotMatrix); aiQuaterniont( const aiMatrix3x3t<TReal>& pRotMatrix);
/** Construct from euler angles */ /** Construct from euler angles */
aiQuaterniont( TReal rotx, TReal roty, TReal rotz); aiQuaterniont( TReal rotx, TReal roty, TReal rotz);
/** Construct from an axis-angle pair */ /** Construct from an axis-angle pair */
aiQuaterniont( aiVector3t<TReal> axis, TReal angle); aiQuaterniont( aiVector3t<TReal> axis, TReal angle);
/** Construct from a normalized quaternion stored in a vec3 */ /** Construct from a normalized quaternion stored in a vec3 */
aiQuaterniont( aiVector3t<TReal> normalized); aiQuaterniont( aiVector3t<TReal> normalized);
/** Returns a matrix representation of the quaternion */ /** Returns a matrix representation of the quaternion */
aiMatrix3x3t<TReal> GetMatrix() const; aiMatrix3x3t<TReal> GetMatrix() const;
public: public:
bool operator== (const aiQuaterniont& o) const; bool operator== (const aiQuaterniont& o) const;
bool operator!= (const aiQuaterniont& o) const; bool operator!= (const aiQuaterniont& o) const;
bool Equal(const aiQuaterniont& o, TReal epsilon = 1e-6) const; bool Equal(const aiQuaterniont& o, TReal epsilon = 1e-6) const;
public: public:
/** Normalize the quaternion */ /** Normalize the quaternion */
aiQuaterniont& Normalize(); aiQuaterniont& Normalize();
/** Compute quaternion conjugate */ /** Compute quaternion conjugate */
aiQuaterniont& Conjugate (); aiQuaterniont& Conjugate ();
/** Rotate a point by this quaternion */ /** Rotate a point by this quaternion */
aiVector3t<TReal> Rotate (const aiVector3t<TReal>& in); aiVector3t<TReal> Rotate (const aiVector3t<TReal>& in);
/** Multiply two quaternions */ /** Multiply two quaternions */
aiQuaterniont operator* (const aiQuaterniont& two) const; aiQuaterniont operator* (const aiQuaterniont& two) const;
public: public:
/** Performs a spherical interpolation between two quaternions and writes the result into the third. /** Performs a spherical interpolation between two quaternions and writes the result into the third.
* @param pOut Target object to received the interpolated rotation. * @param pOut Target object to received the interpolated rotation.
* @param pStart Start rotation of the interpolation at factor == 0. * @param pStart Start rotation of the interpolation at factor == 0.
* @param pEnd End rotation, factor == 1. * @param pEnd End rotation, factor == 1.
* @param pFactor Interpolation factor between 0 and 1. Values outside of this range yield undefined results. * @param pFactor Interpolation factor between 0 and 1. Values outside of this range yield undefined results.
*/ */
static void Interpolate( aiQuaterniont& pOut, const aiQuaterniont& pStart, static void Interpolate( aiQuaterniont& pOut, const aiQuaterniont& pStart,
const aiQuaterniont& pEnd, TReal pFactor); const aiQuaterniont& pEnd, TReal pFactor);
public: public:
//! w,x,y,z components of the quaternion //! w,x,y,z components of the quaternion
TReal w, x, y, z; TReal w, x, y, z;
} ; } ;
typedef aiQuaterniont<float> aiQuaternion; typedef aiQuaterniont<float> aiQuaternion;
@ -117,7 +117,7 @@ typedef aiQuaterniont<float> aiQuaternion;
#else #else
struct aiQuaternion { struct aiQuaternion {
float w, x, y, z; float w, x, y, z;
}; };
#endif #endif

272
include/assimp/quaternion.inl
View File

@ -54,24 +54,24 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
template<typename TReal> template<typename TReal>
bool aiQuaterniont<TReal>::operator== (const aiQuaterniont& o) const bool aiQuaterniont<TReal>::operator== (const aiQuaterniont& o) const
{ {
return x == o.x && y == o.y && z == o.z && w == o.w; return x == o.x && y == o.y && z == o.z && w == o.w;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
bool aiQuaterniont<TReal>::operator!= (const aiQuaterniont& o) const bool aiQuaterniont<TReal>::operator!= (const aiQuaterniont& o) const
{ {
return !(*this == o); return !(*this == o);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
inline bool aiQuaterniont<TReal>::Equal(const aiQuaterniont& o, TReal epsilon) const { inline bool aiQuaterniont<TReal>::Equal(const aiQuaterniont& o, TReal epsilon) const {
return return
std::abs(x - o.x) <= epsilon && std::abs(x - o.x) <= epsilon &&
std::abs(y - o.y) <= epsilon && std::abs(y - o.y) <= epsilon &&
std::abs(z - o.z) <= epsilon && std::abs(z - o.z) <= epsilon &&
std::abs(w - o.w) <= epsilon; std::abs(w - o.w) <= epsilon;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -79,43 +79,43 @@ inline bool aiQuaterniont<TReal>::Equal(const aiQuaterniont& o, TReal epsilon) c
template<typename TReal> template<typename TReal>
inline aiQuaterniont<TReal>::aiQuaterniont( const aiMatrix3x3t<TReal> &pRotMatrix) inline aiQuaterniont<TReal>::aiQuaterniont( const aiMatrix3x3t<TReal> &pRotMatrix)
{ {
TReal t = pRotMatrix.a1 + pRotMatrix.b2 + pRotMatrix.c3; TReal t = pRotMatrix.a1 + pRotMatrix.b2 + pRotMatrix.c3;
// large enough // large enough
if( t > static_cast<TReal>(0)) if( t > static_cast<TReal>(0))
{ {
TReal s = std::sqrt(1 + t) * static_cast<TReal>(2.0); TReal s = std::sqrt(1 + t) * static_cast<TReal>(2.0);
x = (pRotMatrix.c2 - pRotMatrix.b3) / s; x = (pRotMatrix.c2 - pRotMatrix.b3) / s;
y = (pRotMatrix.a3 - pRotMatrix.c1) / s; y = (pRotMatrix.a3 - pRotMatrix.c1) / s;
z = (pRotMatrix.b1 - pRotMatrix.a2) / s; z = (pRotMatrix.b1 - pRotMatrix.a2) / s;
w = static_cast<TReal>(0.25) * s; w = static_cast<TReal>(0.25) * s;
} // else we have to check several cases } // else we have to check several cases
else if( pRotMatrix.a1 > pRotMatrix.b2 && pRotMatrix.a1 > pRotMatrix.c3 ) else if( pRotMatrix.a1 > pRotMatrix.b2 && pRotMatrix.a1 > pRotMatrix.c3 )
{ {
// Column 0: // Column 0:
TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.a1 - pRotMatrix.b2 - pRotMatrix.c3) * static_cast<TReal>(2.0); TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.a1 - pRotMatrix.b2 - pRotMatrix.c3) * static_cast<TReal>(2.0);
x = static_cast<TReal>(0.25) * s; x = static_cast<TReal>(0.25) * s;
y = (pRotMatrix.b1 + pRotMatrix.a2) / s; y = (pRotMatrix.b1 + pRotMatrix.a2) / s;
z = (pRotMatrix.a3 + pRotMatrix.c1) / s; z = (pRotMatrix.a3 + pRotMatrix.c1) / s;
w = (pRotMatrix.c2 - pRotMatrix.b3) / s; w = (pRotMatrix.c2 - pRotMatrix.b3) / s;
} }
else if( pRotMatrix.b2 > pRotMatrix.c3) else if( pRotMatrix.b2 > pRotMatrix.c3)
{ {
// Column 1: // Column 1:
TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.b2 - pRotMatrix.a1 - pRotMatrix.c3) * static_cast<TReal>(2.0); TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.b2 - pRotMatrix.a1 - pRotMatrix.c3) * static_cast<TReal>(2.0);
x = (pRotMatrix.b1 + pRotMatrix.a2) / s; x = (pRotMatrix.b1 + pRotMatrix.a2) / s;
y = static_cast<TReal>(0.25) * s; y = static_cast<TReal>(0.25) * s;
z = (pRotMatrix.c2 + pRotMatrix.b3) / s; z = (pRotMatrix.c2 + pRotMatrix.b3) / s;
w = (pRotMatrix.a3 - pRotMatrix.c1) / s; w = (pRotMatrix.a3 - pRotMatrix.c1) / s;
} else } else
{ {
// Column 2: // Column 2:
TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.c3 - pRotMatrix.a1 - pRotMatrix.b2) * static_cast<TReal>(2.0); TReal s = std::sqrt( static_cast<TReal>(1.0) + pRotMatrix.c3 - pRotMatrix.a1 - pRotMatrix.b2) * static_cast<TReal>(2.0);
x = (pRotMatrix.a3 + pRotMatrix.c1) / s; x = (pRotMatrix.a3 + pRotMatrix.c1) / s;
y = (pRotMatrix.c2 + pRotMatrix.b3) / s; y = (pRotMatrix.c2 + pRotMatrix.b3) / s;
z = static_cast<TReal>(0.25) * s; z = static_cast<TReal>(0.25) * s;
w = (pRotMatrix.b1 - pRotMatrix.a2) / s; w = (pRotMatrix.b1 - pRotMatrix.a2) / s;
} }
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -123,18 +123,18 @@ inline aiQuaterniont<TReal>::aiQuaterniont( const aiMatrix3x3t<TReal> &pRotMatri
template<typename TReal> template<typename TReal>
inline aiQuaterniont<TReal>::aiQuaterniont( TReal fPitch, TReal fYaw, TReal fRoll ) inline aiQuaterniont<TReal>::aiQuaterniont( TReal fPitch, TReal fYaw, TReal fRoll )
{ {
const TReal fSinPitch(std::sin(fPitch*static_cast<TReal>(0.5))); const TReal fSinPitch(std::sin(fPitch*static_cast<TReal>(0.5)));
const TReal fCosPitch(std::cos(fPitch*static_cast<TReal>(0.5))); const TReal fCosPitch(std::cos(fPitch*static_cast<TReal>(0.5)));
const TReal fSinYaw(std::sin(fYaw*static_cast<TReal>(0.5))); const TReal fSinYaw(std::sin(fYaw*static_cast<TReal>(0.5)));
const TReal fCosYaw(std::cos(fYaw*static_cast<TReal>(0.5))); const TReal fCosYaw(std::cos(fYaw*static_cast<TReal>(0.5)));
const TReal fSinRoll(std::sin(fRoll*static_cast<TReal>(0.5))); const TReal fSinRoll(std::sin(fRoll*static_cast<TReal>(0.5)));
const TReal fCosRoll(std::cos(fRoll*static_cast<TReal>(0.5))); const TReal fCosRoll(std::cos(fRoll*static_cast<TReal>(0.5)));
const TReal fCosPitchCosYaw(fCosPitch*fCosYaw); const TReal fCosPitchCosYaw(fCosPitch*fCosYaw);
const TReal fSinPitchSinYaw(fSinPitch*fSinYaw); const TReal fSinPitchSinYaw(fSinPitch*fSinYaw);
x = fSinRoll * fCosPitchCosYaw - fCosRoll * fSinPitchSinYaw; x = fSinRoll * fCosPitchCosYaw - fCosRoll * fSinPitchSinYaw;
y = fCosRoll * fSinPitch * fCosYaw + fSinRoll * fCosPitch * fSinYaw; y = fCosRoll * fSinPitch * fCosYaw + fSinRoll * fCosPitch * fSinYaw;
z = fCosRoll * fCosPitch * fSinYaw - fSinRoll * fSinPitch * fCosYaw; z = fCosRoll * fCosPitch * fSinYaw - fSinRoll * fSinPitch * fCosYaw;
w = fCosRoll * fCosPitchCosYaw + fSinRoll * fSinPitchSinYaw; w = fCosRoll * fCosPitchCosYaw + fSinRoll * fSinPitchSinYaw;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -142,18 +142,18 @@ inline aiQuaterniont<TReal>::aiQuaterniont( TReal fPitch, TReal fYaw, TReal fRol
template<typename TReal> template<typename TReal>
inline aiMatrix3x3t<TReal> aiQuaterniont<TReal>::GetMatrix() const inline aiMatrix3x3t<TReal> aiQuaterniont<TReal>::GetMatrix() const
{ {
aiMatrix3x3t<TReal> resMatrix; aiMatrix3x3t<TReal> resMatrix;
resMatrix.a1 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (y * y + z * z); resMatrix.a1 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (y * y + z * z);
resMatrix.a2 = static_cast<TReal>(2.0) * (x * y - z * w); resMatrix.a2 = static_cast<TReal>(2.0) * (x * y - z * w);
resMatrix.a3 = static_cast<TReal>(2.0) * (x * z + y * w); resMatrix.a3 = static_cast<TReal>(2.0) * (x * z + y * w);
resMatrix.b1 = static_cast<TReal>(2.0) * (x * y + z * w); resMatrix.b1 = static_cast<TReal>(2.0) * (x * y + z * w);
resMatrix.b2 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (x * x + z * z); resMatrix.b2 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (x * x + z * z);
resMatrix.b3 = static_cast<TReal>(2.0) * (y * z - x * w); resMatrix.b3 = static_cast<TReal>(2.0) * (y * z - x * w);
resMatrix.c1 = static_cast<TReal>(2.0) * (x * z - y * w); resMatrix.c1 = static_cast<TReal>(2.0) * (x * z - y * w);
resMatrix.c2 = static_cast<TReal>(2.0) * (y * z + x * w); resMatrix.c2 = static_cast<TReal>(2.0) * (y * z + x * w);
resMatrix.c3 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (x * x + y * y); resMatrix.c3 = static_cast<TReal>(1.0) - static_cast<TReal>(2.0) * (x * x + y * y);
return resMatrix; return resMatrix;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -161,30 +161,30 @@ inline aiMatrix3x3t<TReal> aiQuaterniont<TReal>::GetMatrix() const
template<typename TReal> template<typename TReal>
inline aiQuaterniont<TReal>::aiQuaterniont( aiVector3t<TReal> axis, TReal angle) inline aiQuaterniont<TReal>::aiQuaterniont( aiVector3t<TReal> axis, TReal angle)
{ {
axis.Normalize(); axis.Normalize();
const TReal sin_a = std::sin( angle / 2 ); const TReal sin_a = std::sin( angle / 2 );
const TReal cos_a = std::cos( angle / 2 ); const TReal cos_a = std::cos( angle / 2 );
x = axis.x * sin_a; x = axis.x * sin_a;
y = axis.y * sin_a; y = axis.y * sin_a;
z = axis.z * sin_a; z = axis.z * sin_a;
w = cos_a; w = cos_a;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Construction from am existing, normalized quaternion // Construction from am existing, normalized quaternion
template<typename TReal> template<typename TReal>
inline aiQuaterniont<TReal>::aiQuaterniont( aiVector3t<TReal> normalized) inline aiQuaterniont<TReal>::aiQuaterniont( aiVector3t<TReal> normalized)
{ {
x = normalized.x; x = normalized.x;
y = normalized.y; y = normalized.y;
z = normalized.z; z = normalized.z;
const TReal t = static_cast<TReal>(1.0) - (x*x) - (y*y) - (z*z); const TReal t = static_cast<TReal>(1.0) - (x*x) - (y*y) - (z*z);
if (t < static_cast<TReal>(0.0)) { if (t < static_cast<TReal>(0.0)) {
w = static_cast<TReal>(0.0); w = static_cast<TReal>(0.0);
} }
else w = std::sqrt (t); else w = std::sqrt (t);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -194,89 +194,89 @@ inline aiQuaterniont<TReal>::aiQuaterniont( aiVector3t<TReal> normalized)
template<typename TReal> template<typename TReal>
inline void aiQuaterniont<TReal>::Interpolate( aiQuaterniont& pOut, const aiQuaterniont& pStart, const aiQuaterniont& pEnd, TReal pFactor) inline void aiQuaterniont<TReal>::Interpolate( aiQuaterniont& pOut, const aiQuaterniont& pStart, const aiQuaterniont& pEnd, TReal pFactor)
{ {
// calc cosine theta // calc cosine theta
TReal cosom = pStart.x * pEnd.x + pStart.y * pEnd.y + pStart.z * pEnd.z + pStart.w * pEnd.w; TReal cosom = pStart.x * pEnd.x + pStart.y * pEnd.y + pStart.z * pEnd.z + pStart.w * pEnd.w;
// adjust signs (if necessary) // adjust signs (if necessary)
aiQuaterniont end = pEnd; aiQuaterniont end = pEnd;
if( cosom < static_cast<TReal>(0.0)) if( cosom < static_cast<TReal>(0.0))
{ {
cosom = -cosom; cosom = -cosom;
end.x = -end.x; // Reverse all signs end.x = -end.x; // Reverse all signs
end.y = -end.y; end.y = -end.y;
end.z = -end.z; end.z = -end.z;
end.w = -end.w; end.w = -end.w;
} }
// Calculate coefficients // Calculate coefficients
TReal sclp, sclq; TReal sclp, sclq;
if( (static_cast<TReal>(1.0) - cosom) > static_cast<TReal>(0.0001)) // 0.0001 -> some epsillon if( (static_cast<TReal>(1.0) - cosom) > static_cast<TReal>(0.0001)) // 0.0001 -> some epsillon
{ {
// Standard case (slerp) // Standard case (slerp)
TReal omega, sinom; TReal omega, sinom;
omega = std::acos( cosom); // extract theta from dot product's cos theta omega = std::acos( cosom); // extract theta from dot product's cos theta
sinom = std::sin( omega); sinom = std::sin( omega);
sclp = std::sin( (static_cast<TReal>(1.0) - pFactor) * omega) / sinom; sclp = std::sin( (static_cast<TReal>(1.0) - pFactor) * omega) / sinom;
sclq = std::sin( pFactor * omega) / sinom; sclq = std::sin( pFactor * omega) / sinom;
} else } else
{ {
// Very close, do linear interp (because it's faster) // Very close, do linear interp (because it's faster)
sclp = static_cast<TReal>(1.0) - pFactor; sclp = static_cast<TReal>(1.0) - pFactor;
sclq = pFactor; sclq = pFactor;
} }
pOut.x = sclp * pStart.x + sclq * end.x; pOut.x = sclp * pStart.x + sclq * end.x;
pOut.y = sclp * pStart.y + sclq * end.y; pOut.y = sclp * pStart.y + sclq * end.y;
pOut.z = sclp * pStart.z + sclq * end.z; pOut.z = sclp * pStart.z + sclq * end.z;
pOut.w = sclp * pStart.w + sclq * end.w; pOut.w = sclp * pStart.w + sclq * end.w;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
inline aiQuaterniont<TReal>& aiQuaterniont<TReal>::Normalize() inline aiQuaterniont<TReal>& aiQuaterniont<TReal>::Normalize()
{ {
// compute the magnitude and divide through it // compute the magnitude and divide through it
const TReal mag = std::sqrt(x*x + y*y + z*z + w*w); const TReal mag = std::sqrt(x*x + y*y + z*z + w*w);
if (mag) if (mag)
{ {
const TReal invMag = static_cast<TReal>(1.0)/mag; const TReal invMag = static_cast<TReal>(1.0)/mag;
x *= invMag; x *= invMag;
y *= invMag; y *= invMag;
z *= invMag; z *= invMag;
w *= invMag; w *= invMag;
} }
return *this; return *this;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
inline aiQuaterniont<TReal> aiQuaterniont<TReal>::operator* (const aiQuaterniont& t) const inline aiQuaterniont<TReal> aiQuaterniont<TReal>::operator* (const aiQuaterniont& t) const
{ {
return aiQuaterniont(w*t.w - x*t.x - y*t.y - z*t.z, return aiQuaterniont(w*t.w - x*t.x - y*t.y - z*t.z,
w*t.x + x*t.w + y*t.z - z*t.y, w*t.x + x*t.w + y*t.z - z*t.y,
w*t.y + y*t.w + z*t.x - x*t.z, w*t.y + y*t.w + z*t.x - x*t.z,
w*t.z + z*t.w + x*t.y - y*t.x); w*t.z + z*t.w + x*t.y - y*t.x);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
inline aiQuaterniont<TReal>& aiQuaterniont<TReal>::Conjugate () inline aiQuaterniont<TReal>& aiQuaterniont<TReal>::Conjugate ()
{ {
x = -x; x = -x;
y = -y; y = -y;
z = -z; z = -z;
return *this; return *this;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
inline aiVector3t<TReal> aiQuaterniont<TReal>::Rotate (const aiVector3t<TReal>& v) inline aiVector3t<TReal> aiQuaterniont<TReal>::Rotate (const aiVector3t<TReal>& v)
{ {
aiQuaterniont q2(0.f,v.x,v.y,v.z), q = *this, qinv = q; aiQuaterniont q2(0.f,v.x,v.y,v.z), q = *this, qinv = q;
qinv.Conjugate(); qinv.Conjugate();
q = q*q2*qinv; q = q*q2*qinv;
return aiVector3t<TReal>(q.x,q.y,q.z); return aiVector3t<TReal>(q.x,q.y,q.z);
} }
#endif #endif

444
include/assimp/scene.h
View File

@ -70,145 +70,145 @@ extern "C" {
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
struct aiNode struct aiNode
{ {
/** The name of the node. /** The name of the node.
* *
* The name might be empty (length of zero) but all nodes which * The name might be empty (length of zero) but all nodes which
* need to be referenced by either bones or animations are named. * need to be referenced by either bones or animations are named.
* Multiple nodes may have the same name, except for nodes which are referenced * Multiple nodes may have the same name, except for nodes which are referenced
* by bones (see #aiBone and #aiMesh::mBones). Their names *must* be unique. * by bones (see #aiBone and #aiMesh::mBones). Their names *must* be unique.
* *
* Cameras and lights reference a specific node by name - if there * Cameras and lights reference a specific node by name - if there
* are multiple nodes with this name, they are assigned to each of them. * are multiple nodes with this name, they are assigned to each of them.
* <br> * <br>
* There are no limitations with regard to the characters contained in * There are no limitations with regard to the characters contained in
* the name string as it is usually taken directly from the source file. * the name string as it is usually taken directly from the source file.
* *
* Implementations should be able to handle tokens such as whitespace, tabs, * Implementations should be able to handle tokens such as whitespace, tabs,
* line feeds, quotation marks, ampersands etc. * line feeds, quotation marks, ampersands etc.
* *
* Sometimes assimp introduces new nodes not present in the source file * Sometimes assimp introduces new nodes not present in the source file
* into the hierarchy (usually out of necessity because sometimes the * into the hierarchy (usually out of necessity because sometimes the
* source hierarchy format is simply not compatible). Their names are * source hierarchy format is simply not compatible). Their names are
* surrounded by @verbatim <> @endverbatim e.g. * surrounded by @verbatim <> @endverbatim e.g.
* @verbatim<DummyRootNode> @endverbatim. * @verbatim<DummyRootNode> @endverbatim.
*/ */
C_STRUCT aiString mName; C_STRUCT aiString mName;
/** The transformation relative to the node's parent. */ /** The transformation relative to the node's parent. */
C_STRUCT aiMatrix4x4 mTransformation; C_STRUCT aiMatrix4x4 mTransformation;
/** Parent node. NULL if this node is the root node. */ /** Parent node. NULL if this node is the root node. */
C_STRUCT aiNode* mParent; C_STRUCT aiNode* mParent;
/** The number of child nodes of this node. */ /** The number of child nodes of this node. */
unsigned int mNumChildren; unsigned int mNumChildren;
/** The child nodes of this node. NULL if mNumChildren is 0. */ /** The child nodes of this node. NULL if mNumChildren is 0. */
C_STRUCT aiNode** mChildren; C_STRUCT aiNode** mChildren;
/** The number of meshes of this node. */ /** The number of meshes of this node. */
unsigned int mNumMeshes; unsigned int mNumMeshes;
/** The meshes of this node. Each entry is an index into the mesh */ /** The meshes of this node. Each entry is an index into the mesh */
unsigned int* mMeshes; unsigned int* mMeshes;
/** Metadata associated with this node or NULL if there is no metadata. /** Metadata associated with this node or NULL if there is no metadata.
* Whether any metadata is generated depends on the source file format. See the * Whether any metadata is generated depends on the source file format. See the
* @link importer_notes @endlink page for more information on every source file * @link importer_notes @endlink page for more information on every source file
* format. Importers that don't document any metadata don't write any. * format. Importers that don't document any metadata don't write any.
*/ */
C_STRUCT aiMetadata* mMetaData; C_STRUCT aiMetadata* mMetaData;
#ifdef __cplusplus #ifdef __cplusplus
/** Constructor */ /** Constructor */
aiNode() aiNode()
// set all members to zero by default // set all members to zero by default
: mName("") : mName("")
, mParent(NULL) , mParent(NULL)
, mNumChildren(0) , mNumChildren(0)
, mChildren(NULL) , mChildren(NULL)
, mNumMeshes(0) , mNumMeshes(0)
, mMeshes(NULL) , mMeshes(NULL)
, mMetaData(NULL) , mMetaData(NULL)
{ {
} }
/** Construction from a specific name */ /** Construction from a specific name */
aiNode(const std::string& name) aiNode(const std::string& name)
// set all members to zero by default // set all members to zero by default
: mName(name) : mName(name)
, mParent(NULL) , mParent(NULL)
, mNumChildren(0) , mNumChildren(0)
, mChildren(NULL) , mChildren(NULL)
, mNumMeshes(0) , mNumMeshes(0)
, mMeshes(NULL) , mMeshes(NULL)
, mMetaData(NULL) , mMetaData(NULL)
{ {
} }
/** Destructor */ /** Destructor */
~aiNode() ~aiNode()
{ {
// delete all children recursively // delete all children recursively
// to make sure we won't crash if the data is invalid ... // to make sure we won't crash if the data is invalid ...
if (mChildren && mNumChildren) if (mChildren && mNumChildren)
{ {
for( unsigned int a = 0; a < mNumChildren; a++) for( unsigned int a = 0; a < mNumChildren; a++)
delete mChildren[a]; delete mChildren[a];
} }
delete [] mChildren; delete [] mChildren;
delete [] mMeshes; delete [] mMeshes;
delete mMetaData; delete mMetaData;
} }
/** Searches for a node with a specific name, beginning at this /** Searches for a node with a specific name, beginning at this
* nodes. Normally you will call this method on the root node * nodes. Normally you will call this method on the root node
* of the scene. * of the scene.
* *
* @param name Name to search for * @param name Name to search for
* @return NULL or a valid Node if the search was successful. * @return NULL or a valid Node if the search was successful.
*/ */
inline const aiNode* FindNode(const aiString& name) const inline const aiNode* FindNode(const aiString& name) const
{ {
return FindNode(name.data); return FindNode(name.data);
} }
inline aiNode* FindNode(const aiString& name) inline aiNode* FindNode(const aiString& name)
{ {
return FindNode(name.data); return FindNode(name.data);
} }
inline const aiNode* FindNode(const char* name) const inline const aiNode* FindNode(const char* name) const
{ {
if (!::strcmp( mName.data,name))return this; if (!::strcmp( mName.data,name))return this;
for (unsigned int i = 0; i < mNumChildren;++i) for (unsigned int i = 0; i < mNumChildren;++i)
{ {
const aiNode* const p = mChildren[i]->FindNode(name); const aiNode* const p = mChildren[i]->FindNode(name);
if (p) { if (p) {
return p; return p;
} }
} }
// there is definitely no sub-node with this name // there is definitely no sub-node with this name
return NULL; return NULL;
} }
inline aiNode* FindNode(const char* name) inline aiNode* FindNode(const char* name)
{ {
if (!::strcmp( mName.data,name))return this; if (!::strcmp( mName.data,name))return this;
for (unsigned int i = 0; i < mNumChildren;++i) for (unsigned int i = 0; i < mNumChildren;++i)
{ {
aiNode* const p = mChildren[i]->FindNode(name); aiNode* const p = mChildren[i]->FindNode(name);
if (p) { if (p) {
return p; return p;
} }
} }
// there is definitely no sub-node with this name // there is definitely no sub-node with this name
return NULL; return NULL;
} }
#endif // __cplusplus #endif // __cplusplus
}; };
@ -221,14 +221,14 @@ struct aiNode
* of animation skeletons, material libraries or camera animation paths * of animation skeletons, material libraries or camera animation paths
* using Assimp. Most applications won't support such data. * using Assimp. Most applications won't support such data.
*/ */
#define AI_SCENE_FLAGS_INCOMPLETE 0x1 #define AI_SCENE_FLAGS_INCOMPLETE 0x1
/** /**
* This flag is set by the validation postprocess-step (aiPostProcess_ValidateDS) * This flag is set by the validation postprocess-step (aiPostProcess_ValidateDS)
* if the validation is successful. In a validated scene you can be sure that * if the validation is successful. In a validated scene you can be sure that
* any cross references in the data structure (e.g. vertex indices) are valid. * any cross references in the data structure (e.g. vertex indices) are valid.
*/ */
#define AI_SCENE_FLAGS_VALIDATED 0x2 #define AI_SCENE_FLAGS_VALIDATED 0x2
/** /**
* This flag is set by the validation postprocess-step (aiPostProcess_ValidateDS) * This flag is set by the validation postprocess-step (aiPostProcess_ValidateDS)
@ -238,7 +238,7 @@ struct aiNode
* In most cases you should still be able to use the import. This flag could * In most cases you should still be able to use the import. This flag could
* be useful for applications which don't capture Assimp's log output. * be useful for applications which don't capture Assimp's log output.
*/ */
#define AI_SCENE_FLAGS_VALIDATION_WARNING 0x4 #define AI_SCENE_FLAGS_VALIDATION_WARNING 0x4
/** /**
* This flag is currently only set by the aiProcess_JoinIdenticalVertices step. * This flag is currently only set by the aiProcess_JoinIdenticalVertices step.
@ -246,7 +246,7 @@ struct aiNode
* verbose format anymore. In the verbose format all vertices are unique, * verbose format anymore. In the verbose format all vertices are unique,
* no vertex is ever referenced by more than one face. * no vertex is ever referenced by more than one face.
*/ */
#define AI_SCENE_FLAGS_NON_VERBOSE_FORMAT 0x8 #define AI_SCENE_FLAGS_NON_VERBOSE_FORMAT 0x8
/** /**
* Denotes pure height-map terrain data. Pure terrains usually consist of quads, * Denotes pure height-map terrain data. Pure terrains usually consist of quads,
@ -275,146 +275,146 @@ struct aiNode
struct aiScene struct aiScene
{ {
/** Any combination of the AI_SCENE_FLAGS_XXX flags. By default /** Any combination of the AI_SCENE_FLAGS_XXX flags. By default
* this value is 0, no flags are set. Most applications will * this value is 0, no flags are set. Most applications will
* want to reject all scenes with the AI_SCENE_FLAGS_INCOMPLETE * want to reject all scenes with the AI_SCENE_FLAGS_INCOMPLETE
* bit set. * bit set.
*/ */
unsigned int mFlags; unsigned int mFlags;
/** The root node of the hierarchy. /** The root node of the hierarchy.
* *
* There will always be at least the root node if the import * There will always be at least the root node if the import
* was successful (and no special flags have been set). * was successful (and no special flags have been set).
* Presence of further nodes depends on the format and content * Presence of further nodes depends on the format and content
* of the imported file. * of the imported file.
*/ */
C_STRUCT aiNode* mRootNode; C_STRUCT aiNode* mRootNode;
/** The number of meshes in the scene. */ /** The number of meshes in the scene. */
unsigned int mNumMeshes; unsigned int mNumMeshes;
/** The array of meshes. /** The array of meshes.
* *
* Use the indices given in the aiNode structure to access * Use the indices given in the aiNode structure to access
* this array. The array is mNumMeshes in size. If the * this array. The array is mNumMeshes in size. If the
* AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always * AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always
* be at least ONE material. * be at least ONE material.
*/ */
C_STRUCT aiMesh** mMeshes; C_STRUCT aiMesh** mMeshes;
/** The number of materials in the scene. */ /** The number of materials in the scene. */
unsigned int mNumMaterials; unsigned int mNumMaterials;
/** The array of materials. /** The array of materials.
* *
* Use the index given in each aiMesh structure to access this * Use the index given in each aiMesh structure to access this
* array. The array is mNumMaterials in size. If the * array. The array is mNumMaterials in size. If the
* AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always * AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always
* be at least ONE material. * be at least ONE material.
*/ */
C_STRUCT aiMaterial** mMaterials; C_STRUCT aiMaterial** mMaterials;
/** The number of animations in the scene. */ /** The number of animations in the scene. */
unsigned int mNumAnimations; unsigned int mNumAnimations;
/** The array of animations. /** The array of animations.
* *
* All animations imported from the given file are listed here. * All animations imported from the given file are listed here.
* The array is mNumAnimations in size. * The array is mNumAnimations in size.
*/ */
C_STRUCT aiAnimation** mAnimations; C_STRUCT aiAnimation** mAnimations;
/** The number of textures embedded into the file */ /** The number of textures embedded into the file */
unsigned int mNumTextures; unsigned int mNumTextures;
/** The array of embedded textures. /** The array of embedded textures.
* *
* Not many file formats embed their textures into the file. * Not many file formats embed their textures into the file.
* An example is Quake's MDL format (which is also used by * An example is Quake's MDL format (which is also used by
* some GameStudio versions) * some GameStudio versions)
*/ */
C_STRUCT aiTexture** mTextures; C_STRUCT aiTexture** mTextures;
/** The number of light sources in the scene. Light sources /** The number of light sources in the scene. Light sources
* are fully optional, in most cases this attribute will be 0 * are fully optional, in most cases this attribute will be 0
*/ */
unsigned int mNumLights; unsigned int mNumLights;
/** The array of light sources. /** The array of light sources.
* *
* All light sources imported from the given file are * All light sources imported from the given file are
* listed here. The array is mNumLights in size. * listed here. The array is mNumLights in size.
*/ */
C_STRUCT aiLight** mLights; C_STRUCT aiLight** mLights;
/** The number of cameras in the scene. Cameras /** The number of cameras in the scene. Cameras
* are fully optional, in most cases this attribute will be 0 * are fully optional, in most cases this attribute will be 0
*/ */
unsigned int mNumCameras; unsigned int mNumCameras;
/** The array of cameras. /** The array of cameras.
* *
* All cameras imported from the given file are listed here. * All cameras imported from the given file are listed here.
* The array is mNumCameras in size. The first camera in the * The array is mNumCameras in size. The first camera in the
* array (if existing) is the default camera view into * array (if existing) is the default camera view into
* the scene. * the scene.
*/ */
C_STRUCT aiCamera** mCameras; C_STRUCT aiCamera** mCameras;
#ifdef __cplusplus #ifdef __cplusplus
//! Default constructor - set everything to 0/NULL //! Default constructor - set everything to 0/NULL
ASSIMP_API aiScene(); ASSIMP_API aiScene();
//! Destructor //! Destructor
ASSIMP_API ~aiScene(); ASSIMP_API ~aiScene();
//! Check whether the scene contains meshes //! Check whether the scene contains meshes
//! Unless no special scene flags are set this will always be true. //! Unless no special scene flags are set this will always be true.
inline bool HasMeshes() const inline bool HasMeshes() const
{ return mMeshes != NULL && mNumMeshes > 0; } { return mMeshes != NULL && mNumMeshes > 0; }
//! Check whether the scene contains materials //! Check whether the scene contains materials
//! Unless no special scene flags are set this will always be true. //! Unless no special scene flags are set this will always be true.
inline bool HasMaterials() const inline bool HasMaterials() const
{ return mMaterials != NULL && mNumMaterials > 0; } { return mMaterials != NULL && mNumMaterials > 0; }
//! Check whether the scene contains lights //! Check whether the scene contains lights
inline bool HasLights() const inline bool HasLights() const
{ return mLights != NULL && mNumLights > 0; } { return mLights != NULL && mNumLights > 0; }
//! Check whether the scene contains textures //! Check whether the scene contains textures
inline bool HasTextures() const inline bool HasTextures() const
{ return mTextures != NULL && mNumTextures > 0; } { return mTextures != NULL && mNumTextures > 0; }
//! Check whether the scene contains cameras //! Check whether the scene contains cameras
inline bool HasCameras() const inline bool HasCameras() const
{ return mCameras != NULL && mNumCameras > 0; } { return mCameras != NULL && mNumCameras > 0; }
//! Check whether the scene contains animations //! Check whether the scene contains animations
inline bool HasAnimations() const inline bool HasAnimations() const
{ return mAnimations != NULL && mNumAnimations > 0; } { return mAnimations != NULL && mNumAnimations > 0; }
#endif // __cplusplus #endif // __cplusplus
/** Internal data, do not touch */ /** Internal data, do not touch */
#ifdef __cplusplus #ifdef __cplusplus
void* mPrivate; void* mPrivate;
#else #else
char* mPrivate; char* mPrivate;
#endif #endif
}; };

156
include/assimp/texture.h
View File

@ -66,7 +66,7 @@ extern "C" {
* (zero-based, in the aiScene::mTextures array) * (zero-based, in the aiScene::mTextures array)
*/ */
#if (!defined AI_MAKE_EMBEDDED_TEXNAME) #if (!defined AI_MAKE_EMBEDDED_TEXNAME)
# define AI_MAKE_EMBEDDED_TEXNAME(_n_) "*" # _n_ # define AI_MAKE_EMBEDDED_TEXNAME(_n_) "*" # _n_
#endif #endif
@ -79,28 +79,28 @@ extern "C" {
*/ */
struct aiTexel struct aiTexel
{ {
unsigned char b,g,r,a; unsigned char b,g,r,a;
#ifdef __cplusplus #ifdef __cplusplus
//! Comparison operator //! Comparison operator
bool operator== (const aiTexel& other) const bool operator== (const aiTexel& other) const
{ {
return b == other.b && r == other.r && return b == other.b && r == other.r &&
g == other.g && a == other.a; g == other.g && a == other.a;
} }
//! Inverse comparison operator //! Inverse comparison operator
bool operator!= (const aiTexel& other) const bool operator!= (const aiTexel& other) const
{ {
return b != other.b || r != other.r || return b != other.b || r != other.r ||
g != other.g || a != other.a; g != other.g || a != other.a;
} }
//! Conversion to a floating-point 4d color //! Conversion to a floating-point 4d color
operator aiColor4D() const operator aiColor4D() const
{ {
return aiColor4D(r/255.f,g/255.f,b/255.f,a/255.f); return aiColor4D(r/255.f,g/255.f,b/255.f,a/255.f);
} }
#endif // __cplusplus #endif // __cplusplus
} PACK_STRUCT; } PACK_STRUCT;
@ -119,73 +119,73 @@ struct aiTexel
*/ */
struct aiTexture struct aiTexture
{ {
/** Width of the texture, in pixels /** Width of the texture, in pixels
* *
* If mHeight is zero the texture is compressed in a format * If mHeight is zero the texture is compressed in a format
* like JPEG. In this case mWidth specifies the size of the * like JPEG. In this case mWidth specifies the size of the
* memory area pcData is pointing to, in bytes. * memory area pcData is pointing to, in bytes.
*/ */
unsigned int mWidth; unsigned int mWidth;
/** Height of the texture, in pixels /** Height of the texture, in pixels
* *
* If this value is zero, pcData points to an compressed texture * If this value is zero, pcData points to an compressed texture
* in any format (e.g. JPEG). * in any format (e.g. JPEG).
*/ */
unsigned int mHeight; unsigned int mHeight;
/** A hint from the loader to make it easier for applications /** A hint from the loader to make it easier for applications
* to determine the type of embedded compressed textures. * to determine the type of embedded compressed textures.
* *
* If mHeight != 0 this member is undefined. Otherwise it * If mHeight != 0 this member is undefined. Otherwise it
* is set set to '\\0\\0\\0\\0' if the loader has no additional * is set set to '\\0\\0\\0\\0' if the loader has no additional
* information about the texture file format used OR the * information about the texture file format used OR the
* file extension of the format without a trailing dot. If there * file extension of the format without a trailing dot. If there
* are multiple file extensions for a format, the shortest * are multiple file extensions for a format, the shortest
* extension is chosen (JPEG maps to 'jpg', not to 'jpeg'). * extension is chosen (JPEG maps to 'jpg', not to 'jpeg').
* E.g. 'dds\\0', 'pcx\\0', 'jpg\\0'. All characters are lower-case. * E.g. 'dds\\0', 'pcx\\0', 'jpg\\0'. All characters are lower-case.
* The fourth character will always be '\\0'. * The fourth character will always be '\\0'.
*/ */
char achFormatHint[4]; char achFormatHint[4];
/** Data of the texture. /** Data of the texture.
* *
* Points to an array of mWidth * mHeight aiTexel's. * Points to an array of mWidth * mHeight aiTexel's.
* The format of the texture data is always ARGB8888 to * The format of the texture data is always ARGB8888 to
* make the implementation for user of the library as easy * make the implementation for user of the library as easy
* as possible. If mHeight = 0 this is a pointer to a memory * as possible. If mHeight = 0 this is a pointer to a memory
* buffer of size mWidth containing the compressed texture * buffer of size mWidth containing the compressed texture
* data. Good luck, have fun! * data. Good luck, have fun!
*/ */
C_STRUCT aiTexel* pcData; C_STRUCT aiTexel* pcData;
#ifdef __cplusplus #ifdef __cplusplus
//! For compressed textures (mHeight == 0): compare the //! For compressed textures (mHeight == 0): compare the
//! format hint against a given string. //! format hint against a given string.
//! @param s Input string. 3 characters are maximally processed. //! @param s Input string. 3 characters are maximally processed.
//! Example values: "jpg", "png" //! Example values: "jpg", "png"
//! @return true if the given string matches the format hint //! @return true if the given string matches the format hint
bool CheckFormat(const char* s) const bool CheckFormat(const char* s) const
{ {
return (0 == ::strncmp(achFormatHint,s,3)); return (0 == ::strncmp(achFormatHint,s,3));
} }
// Construction // Construction
aiTexture () aiTexture ()
: mWidth (0) : mWidth (0)
, mHeight (0) , mHeight (0)
, pcData (NULL) , pcData (NULL)
{ {
achFormatHint[0] = achFormatHint[1] = 0; achFormatHint[0] = achFormatHint[1] = 0;
achFormatHint[2] = achFormatHint[3] = 0; achFormatHint[2] = achFormatHint[3] = 0;
} }
// Destruction // Destruction
~aiTexture () ~aiTexture ()
{ {
delete[] pcData; delete[] pcData;
} }
#endif #endif
}; };

504
include/assimp/types.h
View File

@ -66,43 +66,43 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifdef __cplusplus #ifdef __cplusplus
#include <cstring> #include <cstring>
#include <new> // for std::nothrow_t #include <new> // for std::nothrow_t
#include <string> // for aiString::Set(const std::string&) #include <string> // for aiString::Set(const std::string&)
namespace Assimp { namespace Assimp {
//! @cond never //! @cond never
namespace Intern { namespace Intern {
// -------------------------------------------------------------------- // --------------------------------------------------------------------
/** @brief Internal helper class to utilize our internal new/delete /** @brief Internal helper class to utilize our internal new/delete
* routines for allocating object of this and derived classes. * routines for allocating object of this and derived classes.
* *
* By doing this you can safely share class objects between Assimp * By doing this you can safely share class objects between Assimp
* and the application - it works even over DLL boundaries. A good * and the application - it works even over DLL boundaries. A good
* example is the #IOSystem where the application allocates its custom * example is the #IOSystem where the application allocates its custom
* #IOSystem, then calls #Importer::SetIOSystem(). When the Importer * #IOSystem, then calls #Importer::SetIOSystem(). When the Importer
* destructs, Assimp calls operator delete on the stored #IOSystem. * destructs, Assimp calls operator delete on the stored #IOSystem.
* If it lies on a different heap than Assimp is working with, * If it lies on a different heap than Assimp is working with,
* the application is determined to crash. * the application is determined to crash.
*/ */
// -------------------------------------------------------------------- // --------------------------------------------------------------------
#ifndef SWIG #ifndef SWIG
struct ASSIMP_API AllocateFromAssimpHeap { struct ASSIMP_API AllocateFromAssimpHeap {
// http://www.gotw.ca/publications/mill15.htm // http://www.gotw.ca/publications/mill15.htm
// new/delete overload // new/delete overload
void *operator new ( size_t num_bytes) /* throw( std::bad_alloc ) */; 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 new ( size_t num_bytes, const std::nothrow_t& ) throw();
void operator delete ( void* data); void operator delete ( void* data);
// array new/delete overload // array new/delete overload
void *operator new[] ( size_t num_bytes) /* throw( std::bad_alloc ) */; 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 new[] ( size_t num_bytes, const std::nothrow_t& ) throw();
void operator delete[] ( void* data); void operator delete[] ( void* data);
}; // struct AllocateFromAssimpHeap }; // struct AllocateFromAssimpHeap
#endif #endif
} // namespace Intern } // namespace Intern
//! @endcond //! @endcond
} // namespace Assimp } // namespace Assimp
extern "C" { extern "C" {
@ -112,7 +112,7 @@ extern "C" {
#ifdef __cplusplus #ifdef __cplusplus
const size_t MAXLEN = 1024; const size_t MAXLEN = 1024;
#else #else
# define MAXLEN 1024 # define MAXLEN 1024
#endif #endif
#include "./Compiler/pushpack1.h" #include "./Compiler/pushpack1.h"
@ -123,16 +123,16 @@ const size_t MAXLEN = 1024;
struct aiPlane struct aiPlane
{ {
#ifdef __cplusplus #ifdef __cplusplus
aiPlane () : a(0.f), b(0.f), c(0.f), d(0.f) {} aiPlane () : a(0.f), b(0.f), c(0.f), d(0.f) {}
aiPlane (float _a, float _b, float _c, float _d) aiPlane (float _a, float _b, float _c, float _d)
: a(_a), b(_b), c(_c), d(_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) {} aiPlane (const aiPlane& o) : a(o.a), b(o.b), c(o.c), d(o.d) {}
#endif // !__cplusplus #endif // !__cplusplus
//! Plane equation //! Plane equation
float a,b,c,d; float a,b,c,d;
} PACK_STRUCT; // !struct aiPlane } PACK_STRUCT; // !struct aiPlane
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
@ -141,16 +141,16 @@ struct aiPlane
struct aiRay struct aiRay
{ {
#ifdef __cplusplus #ifdef __cplusplus
aiRay () {} aiRay () {}
aiRay (const aiVector3D& _pos, const aiVector3D& _dir) aiRay (const aiVector3D& _pos, const aiVector3D& _dir)
: pos(_pos), dir(_dir) {} : pos(_pos), dir(_dir) {}
aiRay (const aiRay& o) : pos (o.pos), dir (o.dir) {} aiRay (const aiRay& o) : pos (o.pos), dir (o.dir) {}
#endif // !__cplusplus #endif // !__cplusplus
//! Position and direction of the ray //! Position and direction of the ray
C_STRUCT aiVector3D pos, dir; C_STRUCT aiVector3D pos, dir;
} PACK_STRUCT; // !struct aiRay } PACK_STRUCT; // !struct aiRay
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
@ -159,71 +159,71 @@ struct aiRay
struct aiColor3D struct aiColor3D
{ {
#ifdef __cplusplus #ifdef __cplusplus
aiColor3D () : r(0.0f), g(0.0f), b(0.0f) {} 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, float _g, float _b) : r(_r), g(_g), b(_b) {}
aiColor3D (float _r) : r(_r), g(_r), b(_r) {} aiColor3D (float _r) : r(_r), g(_r), b(_r) {}
aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {} aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {}
/** Component-wise comparison */ /** Component-wise comparison */
// TODO: add epsilon? // TODO: add epsilon?
bool operator == (const aiColor3D& other) const bool operator == (const aiColor3D& other) const
{return r == other.r && g == other.g && b == other.b;} {return r == other.r && g == other.g && b == other.b;}
/** Component-wise inverse comparison */ /** Component-wise inverse comparison */
// TODO: add epsilon? // TODO: add epsilon?
bool operator != (const aiColor3D& other) const bool operator != (const aiColor3D& other) const
{return r != other.r || g != other.g || b != other.b;} {return r != other.r || g != other.g || b != other.b;}
/** Component-wise comparison */ /** Component-wise comparison */
// TODO: add epsilon? // TODO: add epsilon?
bool operator < (const aiColor3D& other) const { bool operator < (const aiColor3D& other) const {
return r < other.r || ( return r < other.r || (
r == other.r && (g < other.g || r == other.r && (g < other.g ||
(g == other.g && b < other.b) (g == other.g && b < other.b)
) )
); );
} }
/** Component-wise addition */ /** Component-wise addition */
aiColor3D operator+(const aiColor3D& c) const { aiColor3D operator+(const aiColor3D& c) const {
return aiColor3D(r+c.r,g+c.g,b+c.b); return aiColor3D(r+c.r,g+c.g,b+c.b);
} }
/** Component-wise subtraction */ /** Component-wise subtraction */
aiColor3D operator-(const aiColor3D& c) const { aiColor3D operator-(const aiColor3D& c) const {
return aiColor3D(r-c.r,g-c.g,b-c.b); return aiColor3D(r-c.r,g-c.g,b-c.b);
} }
/** Component-wise multiplication */ /** Component-wise multiplication */
aiColor3D operator*(const aiColor3D& c) const { aiColor3D operator*(const aiColor3D& c) const {
return aiColor3D(r*c.r,g*c.g,b*c.b); return aiColor3D(r*c.r,g*c.g,b*c.b);
} }
/** Multiply with a scalar */ /** Multiply with a scalar */
aiColor3D operator*(float f) const { aiColor3D operator*(float f) const {
return aiColor3D(r*f,g*f,b*f); return aiColor3D(r*f,g*f,b*f);
} }
/** Access a specific color component */ /** Access a specific color component */
float operator[](unsigned int i) const { float operator[](unsigned int i) const {
return *(&r + i); return *(&r + i);
} }
/** Access a specific color component */ /** Access a specific color component */
float& operator[](unsigned int i) { float& operator[](unsigned int i) {
return *(&r + i); return *(&r + i);
} }
/** Check whether a color is black */ /** Check whether a color is black */
bool IsBlack() const { bool IsBlack() const {
static const float epsilon = 10e-3f; static const float epsilon = 10e-3f;
return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon; return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon;
} }
#endif // !__cplusplus #endif // !__cplusplus
//! Red, green and blue color values //! Red, green and blue color values
float r, g, b; float r, g, b;
} PACK_STRUCT; // !struct aiColor3D } PACK_STRUCT; // !struct aiColor3D
#include "./Compiler/poppack1.h" #include "./Compiler/poppack1.h"
@ -251,143 +251,143 @@ struct aiColor3D
struct aiString struct aiString
{ {
#ifdef __cplusplus #ifdef __cplusplus
/** Default constructor, the string is set to have zero length */ /** Default constructor, the string is set to have zero length */
aiString() : aiString() :
length(0) length(0)
{ {
data[0] = '\0'; data[0] = '\0';
#ifdef ASSIMP_BUILD_DEBUG #ifdef ASSIMP_BUILD_DEBUG
// Debug build: overwrite the string on its full length with ESC (27) // Debug build: overwrite the string on its full length with ESC (27)
memset(data+1,27,MAXLEN-1); memset(data+1,27,MAXLEN-1);
#endif #endif
} }
/** Copy constructor */ /** Copy constructor */
aiString(const aiString& rOther) : aiString(const aiString& rOther) :
length(rOther.length) length(rOther.length)
{ {
// Crop the string to the maximum length // Crop the string to the maximum length
length = length>=MAXLEN?MAXLEN-1:length; length = length>=MAXLEN?MAXLEN-1:length;
memcpy( data, rOther.data, length); memcpy( data, rOther.data, length);
data[length] = '\0'; data[length] = '\0';
} }
/** Constructor from std::string */ /** Constructor from std::string */
explicit aiString(const std::string& pString) : explicit aiString(const std::string& pString) :
length(pString.length()) length(pString.length())
{ {
length = length>=MAXLEN?MAXLEN-1:length; length = length>=MAXLEN?MAXLEN-1:length;
memcpy( data, pString.c_str(), length); memcpy( data, pString.c_str(), length);
data[length] = '\0'; data[length] = '\0';
} }
/** Copy a std::string to the aiString */ /** Copy a std::string to the aiString */
void Set( const std::string& pString) { void Set( const std::string& pString) {
if( pString.length() > MAXLEN - 1) { if( pString.length() > MAXLEN - 1) {
return; return;
} }
length = pString.length(); length = pString.length();
memcpy( data, pString.c_str(), length); memcpy( data, pString.c_str(), length);
data[length] = 0; data[length] = 0;
} }
/** Copy a const char* to the aiString */ /** Copy a const char* to the aiString */
void Set( const char* sz) { void Set( const char* sz) {
const size_t len = ::strlen(sz); const size_t len = ::strlen(sz);
if( len > MAXLEN - 1) { if( len > MAXLEN - 1) {
return; return;
} }
length = len; length = len;
memcpy( data, sz, len); memcpy( data, sz, len);
data[len] = 0; data[len] = 0;
} }
/** Assign a const char* to the string */ /** Assign a const char* to the string */
aiString& operator = (const char* sz) { aiString& operator = (const char* sz) {
Set(sz); Set(sz);
return *this; return *this;
} }
/** Assign a cstd::string to the string */ /** Assign a cstd::string to the string */
aiString& operator = ( const std::string& pString) { aiString& operator = ( const std::string& pString) {
Set(pString); Set(pString);
return *this; return *this;
} }
/** Comparison operator */ /** Comparison operator */
bool operator==(const aiString& other) const { bool operator==(const aiString& other) const {
return (length == other.length && 0 == memcmp(data,other.data,length)); return (length == other.length && 0 == memcmp(data,other.data,length));
} }
/** Inverse comparison operator */ /** Inverse comparison operator */
bool operator!=(const aiString& other) const { bool operator!=(const aiString& other) const {
return (length != other.length || 0 != memcmp(data,other.data,length)); return (length != other.length || 0 != memcmp(data,other.data,length));
} }
/** Append a string to the string */ /** Append a string to the string */
void Append (const char* app) { void Append (const char* app) {
const size_t len = ::strlen(app); const size_t len = ::strlen(app);
if (!len) { if (!len) {
return; return;
} }
if (length + len >= MAXLEN) { if (length + len >= MAXLEN) {
return; return;
} }
memcpy(&data[length],app,len+1); memcpy(&data[length],app,len+1);
length += len; length += len;
} }
/** Clear the string - reset its length to zero */ /** Clear the string - reset its length to zero */
void Clear () { void Clear () {
length = 0; length = 0;
data[0] = '\0'; data[0] = '\0';
#ifdef ASSIMP_BUILD_DEBUG #ifdef ASSIMP_BUILD_DEBUG
// Debug build: overwrite the string on its full length with ESC (27) // Debug build: overwrite the string on its full length with ESC (27)
memset(data+1,27,MAXLEN-1); memset(data+1,27,MAXLEN-1);
#endif #endif
} }
/** Returns a pointer to the underlying zero-terminated array of characters */ /** Returns a pointer to the underlying zero-terminated array of characters */
const char* C_Str() const { const char* C_Str() const {
return data; return data;
} }
#endif // !__cplusplus #endif // !__cplusplus
/** Binary length of the string excluding the terminal 0. This is NOT the /** Binary length of the string excluding the terminal 0. This is NOT the
* logical length of strings containing UTF-8 multibyte sequences! It's * logical length of strings containing UTF-8 multibyte sequences! It's
* the number of bytes from the beginning of the string to its end.*/ * the number of bytes from the beginning of the string to its end.*/
size_t length; size_t length;
/** String buffer. Size limit is MAXLEN */ /** String buffer. Size limit is MAXLEN */
char data[MAXLEN]; char data[MAXLEN];
} ; // !struct aiString } ; // !struct aiString
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
/** Standard return type for some library functions. /** Standard return type for some library functions.
* Rarely used, and if, mostly in the C API. * Rarely used, and if, mostly in the C API.
*/ */
typedef enum aiReturn typedef enum aiReturn
{ {
/** Indicates that a function was successful */ /** Indicates that a function was successful */
aiReturn_SUCCESS = 0x0, aiReturn_SUCCESS = 0x0,
/** Indicates that a function failed */ /** Indicates that a function failed */
aiReturn_FAILURE = -0x1, aiReturn_FAILURE = -0x1,
/** Indicates that not enough memory was available /** Indicates that not enough memory was available
* to perform the requested operation * to perform the requested operation
*/ */
aiReturn_OUTOFMEMORY = -0x3, aiReturn_OUTOFMEMORY = -0x3,
/** @cond never /** @cond never
* Force 32-bit size enum * Force 32-bit size enum
*/ */
_AI_ENFORCE_ENUM_SIZE = 0x7fffffff _AI_ENFORCE_ENUM_SIZE = 0x7fffffff
/// @endcond /// @endcond
} aiReturn; // !enum aiReturn } aiReturn; // !enum aiReturn
@ -403,21 +403,21 @@ typedef enum aiReturn
*/ */
enum aiOrigin enum aiOrigin
{ {
/** Beginning of the file */ /** Beginning of the file */
aiOrigin_SET = 0x0, aiOrigin_SET = 0x0,
/** Current position of the file pointer */ /** Current position of the file pointer */
aiOrigin_CUR = 0x1, aiOrigin_CUR = 0x1,
/** End of the file, offsets must be negative */ /** End of the file, offsets must be negative */
aiOrigin_END = 0x2, aiOrigin_END = 0x2,
/** @cond never /** @cond never
* Force 32-bit size enum * Force 32-bit size enum
*/ */
_AI_ORIGIN_ENFORCE_ENUM_SIZE = 0x7fffffff _AI_ORIGIN_ENFORCE_ENUM_SIZE = 0x7fffffff
/// @endcond /// @endcond
}; // !enum aiOrigin }; // !enum aiOrigin
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
@ -427,25 +427,25 @@ enum aiOrigin
*/ */
enum aiDefaultLogStream enum aiDefaultLogStream
{ {
/** Stream the log to a file */ /** Stream the log to a file */
aiDefaultLogStream_FILE = 0x1, aiDefaultLogStream_FILE = 0x1,
/** Stream the log to std::cout */ /** Stream the log to std::cout */
aiDefaultLogStream_STDOUT = 0x2, aiDefaultLogStream_STDOUT = 0x2,
/** Stream the log to std::cerr */ /** Stream the log to std::cerr */
aiDefaultLogStream_STDERR = 0x4, aiDefaultLogStream_STDERR = 0x4,
/** MSVC only: Stream the log the the debugger /** MSVC only: Stream the log the the debugger
* (this relies on OutputDebugString from the Win32 SDK) * (this relies on OutputDebugString from the Win32 SDK)
*/ */
aiDefaultLogStream_DEBUGGER = 0x8, aiDefaultLogStream_DEBUGGER = 0x8,
/** @cond never /** @cond never
* Force 32-bit size enum * Force 32-bit size enum
*/ */
_AI_DLS_ENFORCE_ENUM_SIZE = 0x7fffffff _AI_DLS_ENFORCE_ENUM_SIZE = 0x7fffffff
/// @endcond /// @endcond
}; // !enum aiDefaultLogStream }; // !enum aiDefaultLogStream
// just for backwards compatibility, don't use these constants anymore // just for backwards compatibility, don't use these constants anymore
@ -463,43 +463,43 @@ struct aiMemoryInfo
{ {
#ifdef __cplusplus #ifdef __cplusplus
/** Default constructor */ /** Default constructor */
aiMemoryInfo() aiMemoryInfo()
: textures (0) : textures (0)
, materials (0) , materials (0)
, meshes (0) , meshes (0)
, nodes (0) , nodes (0)
, animations (0) , animations (0)
, cameras (0) , cameras (0)
, lights (0) , lights (0)
, total (0) , total (0)
{} {}
#endif #endif
/** Storage allocated for texture data */ /** Storage allocated for texture data */
unsigned int textures; unsigned int textures;
/** Storage allocated for material data */ /** Storage allocated for material data */
unsigned int materials; unsigned int materials;
/** Storage allocated for mesh data */ /** Storage allocated for mesh data */
unsigned int meshes; unsigned int meshes;
/** Storage allocated for node data */ /** Storage allocated for node data */
unsigned int nodes; unsigned int nodes;
/** Storage allocated for animation data */ /** Storage allocated for animation data */
unsigned int animations; unsigned int animations;
/** Storage allocated for camera data */ /** Storage allocated for camera data */
unsigned int cameras; unsigned int cameras;
/** Storage allocated for light data */ /** Storage allocated for light data */
unsigned int lights; unsigned int lights;
/** Total storage allocated for the full import. */ /** Total storage allocated for the full import. */
unsigned int total; unsigned int total;
}; // !struct aiMemoryInfo }; // !struct aiMemoryInfo
#ifdef __cplusplus #ifdef __cplusplus

46
include/assimp/vector2.h
View File

@ -62,40 +62,40 @@ class aiVector2t
{ {
public: public:
aiVector2t () : x(), y() {} aiVector2t () : x(), y() {}
aiVector2t (TReal _x, TReal _y) : x(_x), y(_y) {} aiVector2t (TReal _x, TReal _y) : x(_x), y(_y) {}
explicit aiVector2t (TReal _xyz) : x(_xyz), y(_xyz) {} explicit aiVector2t (TReal _xyz) : x(_xyz), y(_xyz) {}
aiVector2t (const aiVector2t& o) : x(o.x), y(o.y) {} aiVector2t (const aiVector2t& o) : x(o.x), y(o.y) {}
public: public:
void Set( TReal pX, TReal pY); void Set( TReal pX, TReal pY);
TReal SquareLength() const ; TReal SquareLength() const ;
TReal Length() const ; TReal Length() const ;
aiVector2t& Normalize(); aiVector2t& Normalize();
public: public:
const aiVector2t& operator += (const aiVector2t& o); const aiVector2t& operator += (const aiVector2t& o);
const aiVector2t& operator -= (const aiVector2t& o); const aiVector2t& operator -= (const aiVector2t& o);
const aiVector2t& operator *= (TReal f); const aiVector2t& operator *= (TReal f);
const aiVector2t& operator /= (TReal f); const aiVector2t& operator /= (TReal f);
TReal operator[](unsigned int i) const; TReal operator[](unsigned int i) const;
TReal& operator[](unsigned int i); TReal& operator[](unsigned int i);
bool operator== (const aiVector2t& other) const; bool operator== (const aiVector2t& other) const;
bool operator!= (const aiVector2t& other) const; bool operator!= (const aiVector2t& other) const;
bool Equal(const aiVector2t& other, TReal epsilon = 1e-6) const; bool Equal(const aiVector2t& other, TReal epsilon = 1e-6) const;
aiVector2t& operator= (TReal f); aiVector2t& operator= (TReal f);
const aiVector2t SymMul(const aiVector2t& o); const aiVector2t SymMul(const aiVector2t& o);
template <typename TOther> template <typename TOther>
operator aiVector2t<TOther> () const; operator aiVector2t<TOther> () const;
TReal x, y; TReal x, y;
} PACK_STRUCT; } PACK_STRUCT;
typedef aiVector2t<float> aiVector2D; typedef aiVector2t<float> aiVector2D;
@ -103,7 +103,7 @@ typedef aiVector2t<float> aiVector2D;
#else #else
struct aiVector2D { struct aiVector2D {
float x,y; float x,y;
}; };
#endif // __cplusplus #endif // __cplusplus

66
include/assimp/vector2.inl
View File

@ -54,104 +54,104 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
template <typename TReal> template <typename TReal>
template <typename TOther> template <typename TOther>
aiVector2t<TReal>::operator aiVector2t<TOther> () const { aiVector2t<TReal>::operator aiVector2t<TOther> () const {
return aiVector2t<TOther>(static_cast<TOther>(x),static_cast<TOther>(y)); return aiVector2t<TOther>(static_cast<TOther>(x),static_cast<TOther>(y));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
void aiVector2t<TReal>::Set( TReal pX, TReal pY) { void aiVector2t<TReal>::Set( TReal pX, TReal pY) {
x = pX; y = pY; x = pX; y = pY;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
TReal aiVector2t<TReal>::SquareLength() const { TReal aiVector2t<TReal>::SquareLength() const {
return x*x + y*y; return x*x + y*y;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
TReal aiVector2t<TReal>::Length() const { TReal aiVector2t<TReal>::Length() const {
return std::sqrt( SquareLength()); return std::sqrt( SquareLength());
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
aiVector2t<TReal>& aiVector2t<TReal>::Normalize() { aiVector2t<TReal>& aiVector2t<TReal>::Normalize() {
*this /= Length(); *this /= Length();
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
const aiVector2t<TReal>& aiVector2t<TReal>::operator += (const aiVector2t& o) { const aiVector2t<TReal>& aiVector2t<TReal>::operator += (const aiVector2t& o) {
x += o.x; y += o.y; x += o.x; y += o.y;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
const aiVector2t<TReal>& aiVector2t<TReal>::operator -= (const aiVector2t& o) { const aiVector2t<TReal>& aiVector2t<TReal>::operator -= (const aiVector2t& o) {
x -= o.x; y -= o.y; x -= o.x; y -= o.y;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
const aiVector2t<TReal>& aiVector2t<TReal>::operator *= (TReal f) { const aiVector2t<TReal>& aiVector2t<TReal>::operator *= (TReal f) {
x *= f; y *= f; x *= f; y *= f;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
const aiVector2t<TReal>& aiVector2t<TReal>::operator /= (TReal f) { const aiVector2t<TReal>& aiVector2t<TReal>::operator /= (TReal f) {
x /= f; y /= f; x /= f; y /= f;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
TReal aiVector2t<TReal>::operator[](unsigned int i) const { TReal aiVector2t<TReal>::operator[](unsigned int i) const {
return *(&x + i); return *(&x + i);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
TReal& aiVector2t<TReal>::operator[](unsigned int i) { TReal& aiVector2t<TReal>::operator[](unsigned int i) {
return *(&x + i); return *(&x + i);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
bool aiVector2t<TReal>::operator== (const aiVector2t& other) const { bool aiVector2t<TReal>::operator== (const aiVector2t& other) const {
return x == other.x && y == other.y; return x == other.x && y == other.y;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
bool aiVector2t<TReal>::operator!= (const aiVector2t& other) const { bool aiVector2t<TReal>::operator!= (const aiVector2t& other) const {
return x != other.x || y != other.y; return x != other.x || y != other.y;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
bool aiVector2t<TReal>::Equal(const aiVector2t& other, TReal epsilon) const { bool aiVector2t<TReal>::Equal(const aiVector2t& other, TReal epsilon) const {
return return
std::abs(x - other.x) <= epsilon && std::abs(x - other.x) <= epsilon &&
std::abs(y - other.y) <= epsilon; std::abs(y - other.y) <= epsilon;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
aiVector2t<TReal>& aiVector2t<TReal>::operator= (TReal f) { aiVector2t<TReal>& aiVector2t<TReal>::operator= (TReal f) {
x = y = f; x = y = f;
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
const aiVector2t<TReal> aiVector2t<TReal>::SymMul(const aiVector2t& o) { const aiVector2t<TReal> aiVector2t<TReal>::SymMul(const aiVector2t& o) {
return aiVector2t(x*o.x,y*o.y); return aiVector2t(x*o.x,y*o.y);
} }
@ -160,7 +160,7 @@ const aiVector2t<TReal> aiVector2t<TReal>::SymMul(const aiVector2t& o) {
template <typename TReal> template <typename TReal>
inline aiVector2t<TReal> operator + (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2) inline aiVector2t<TReal> operator + (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2)
{ {
return aiVector2t<TReal>( v1.x + v2.x, v1.y + v2.y); return aiVector2t<TReal>( v1.x + v2.x, v1.y + v2.y);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -168,7 +168,7 @@ inline aiVector2t<TReal> operator + (const aiVector2t<TReal>& v1, const aiVector
template <typename TReal> template <typename TReal>
inline aiVector2t<TReal> operator - (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2) inline aiVector2t<TReal> operator - (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2)
{ {
return aiVector2t<TReal>( v1.x - v2.x, v1.y - v2.y); return aiVector2t<TReal>( v1.x - v2.x, v1.y - v2.y);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -176,7 +176,7 @@ inline aiVector2t<TReal> operator - (const aiVector2t<TReal>& v1, const aiVector
template <typename TReal> template <typename TReal>
inline TReal operator * (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2) inline TReal operator * (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v2)
{ {
return v1.x*v2.x + v1.y*v2.y; return v1.x*v2.x + v1.y*v2.y;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -184,7 +184,7 @@ inline TReal operator * (const aiVector2t<TReal>& v1, const aiVector2t<TReal>& v
template <typename TReal> template <typename TReal>
inline aiVector2t<TReal> operator * ( TReal f, const aiVector2t<TReal>& v) inline aiVector2t<TReal> operator * ( TReal f, const aiVector2t<TReal>& v)
{ {
return aiVector2t<TReal>( f*v.x, f*v.y); return aiVector2t<TReal>( f*v.x, f*v.y);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -192,7 +192,7 @@ inline aiVector2t<TReal> operator * ( TReal f, const aiVector2t<TReal>& v)
template <typename TReal> template <typename TReal>
inline aiVector2t<TReal> operator * ( const aiVector2t<TReal>& v, TReal f) inline aiVector2t<TReal> operator * ( const aiVector2t<TReal>& v, TReal f)
{ {
return aiVector2t<TReal>( f*v.x, f*v.y); return aiVector2t<TReal>( f*v.x, f*v.y);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -201,7 +201,7 @@ template <typename TReal>
inline aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, TReal f) inline aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, TReal f)
{ {
return v * (1/f); return v * (1/f);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -209,7 +209,7 @@ inline aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, TReal f)
template <typename TReal> template <typename TReal>
inline aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, const aiVector2t<TReal>& v2) inline aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, const aiVector2t<TReal>& v2)
{ {
return aiVector2t<TReal>(v.x / v2.x,v.y / v2.y); return aiVector2t<TReal>(v.x / v2.x,v.y / v2.y);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -217,7 +217,7 @@ inline aiVector2t<TReal> operator / ( const aiVector2t<TReal>& v, const aiVector
template <typename TReal> template <typename TReal>
inline aiVector2t<TReal> operator - ( const aiVector2t<TReal>& v) inline aiVector2t<TReal> operator - ( const aiVector2t<TReal>& v)
{ {
return aiVector2t<TReal>( -v.x, -v.y); return aiVector2t<TReal>( -v.x, -v.y);
} }
#endif #endif

84
include/assimp/vector3.h
View File

@ -64,66 +64,66 @@ class aiVector3t
{ {
public: public:
aiVector3t () : x(), y(), z() {} aiVector3t () : x(), y(), z() {}
aiVector3t (TReal _x, TReal _y, TReal _z) : x(_x), y(_y), z(_z) {} aiVector3t (TReal _x, TReal _y, TReal _z) : x(_x), y(_y), z(_z) {}
explicit aiVector3t (TReal _xyz) : x(_xyz), y(_xyz), z(_xyz) {} explicit aiVector3t (TReal _xyz) : x(_xyz), y(_xyz), z(_xyz) {}
aiVector3t (const aiVector3t& o) : x(o.x), y(o.y), z(o.z) {} aiVector3t (const aiVector3t& o) : x(o.x), y(o.y), z(o.z) {}
public: public:
// combined operators // combined operators
const aiVector3t& operator += (const aiVector3t& o); const aiVector3t& operator += (const aiVector3t& o);
const aiVector3t& operator -= (const aiVector3t& o); const aiVector3t& operator -= (const aiVector3t& o);
const aiVector3t& operator *= (TReal f); const aiVector3t& operator *= (TReal f);
const aiVector3t& operator /= (TReal f); const aiVector3t& operator /= (TReal f);
// transform vector by matrix // transform vector by matrix
aiVector3t& operator *= (const aiMatrix3x3t<TReal>& mat); aiVector3t& operator *= (const aiMatrix3x3t<TReal>& mat);
aiVector3t& operator *= (const aiMatrix4x4t<TReal>& mat); aiVector3t& operator *= (const aiMatrix4x4t<TReal>& mat);
// access a single element // access a single element
TReal operator[](unsigned int i) const; TReal operator[](unsigned int i) const;
TReal& operator[](unsigned int i); TReal& operator[](unsigned int i);
// comparison // comparison
bool operator== (const aiVector3t& other) const; bool operator== (const aiVector3t& other) const;
bool operator!= (const aiVector3t& other) const; bool operator!= (const aiVector3t& other) const;
bool operator < (const aiVector3t& other) const; bool operator < (const aiVector3t& other) const;
bool Equal(const aiVector3t& other, TReal epsilon = 1e-6) const; bool Equal(const aiVector3t& other, TReal epsilon = 1e-6) const;
template <typename TOther> template <typename TOther>
operator aiVector3t<TOther> () const; operator aiVector3t<TOther> () const;
public: public:
/** @brief Set the components of a vector /** @brief Set the components of a vector
* @param pX X component * @param pX X component
* @param pY Y component * @param pY Y component
* @param pZ Z component */ * @param pZ Z component */
void Set( TReal pX, TReal pY, TReal pZ); void Set( TReal pX, TReal pY, TReal pZ);
/** @brief Get the squared length of the vector /** @brief Get the squared length of the vector
* @return Square length */ * @return Square length */
TReal SquareLength() const; TReal SquareLength() const;
/** @brief Get the length of the vector /** @brief Get the length of the vector
* @return length */ * @return length */
TReal Length() const; TReal Length() const;
/** @brief Normalize the vector */ /** @brief Normalize the vector */
aiVector3t& Normalize(); aiVector3t& Normalize();
/** @brief Componentwise multiplication of two vectors /** @brief Componentwise multiplication of two vectors
* *
* Note that vec*vec yields the dot product. * Note that vec*vec yields the dot product.
* @param o Second factor */ * @param o Second factor */
const aiVector3t SymMul(const aiVector3t& o); const aiVector3t SymMul(const aiVector3t& o);
TReal x, y, z; TReal x, y, z;
} PACK_STRUCT; } PACK_STRUCT;
@ -133,7 +133,7 @@ typedef aiVector3t<float> aiVector3D;
struct aiVector3D { struct aiVector3D {
float x,y,z; float x,y,z;
} PACK_STRUCT; } PACK_STRUCT;
#endif // __cplusplus #endif // __cplusplus

98
include/assimp/vector3.inl
View File

@ -55,11 +55,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
template <typename TReal> template <typename TReal>
inline aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) inline aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const aiVector3t<TReal>& pVector)
{ {
aiVector3t<TReal> res; aiVector3t<TReal> res;
res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z; res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z;
res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z; res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z;
res.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z; res.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z;
return res; return res;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -67,159 +67,159 @@ inline aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const a
template <typename TReal> template <typename TReal>
inline aiVector3t<TReal> operator * (const aiMatrix4x4t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) inline aiVector3t<TReal> operator * (const aiMatrix4x4t<TReal>& pMatrix, const aiVector3t<TReal>& pVector)
{ {
aiVector3t<TReal> res; aiVector3t<TReal> res;
res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z + pMatrix.a4; res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z + pMatrix.a4;
res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z + pMatrix.b4; res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z + pMatrix.b4;
res.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z + pMatrix.c4; res.z = pMatrix.c1 * pVector.x + pMatrix.c2 * pVector.y + pMatrix.c3 * pVector.z + pMatrix.c4;
return res; return res;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
template <typename TOther> template <typename TOther>
aiVector3t<TReal>::operator aiVector3t<TOther> () const { aiVector3t<TReal>::operator aiVector3t<TOther> () const {
return aiVector3t<TOther>(static_cast<TOther>(x),static_cast<TOther>(y),static_cast<TOther>(z)); return aiVector3t<TOther>(static_cast<TOther>(x),static_cast<TOther>(y),static_cast<TOther>(z));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE void aiVector3t<TReal>::Set( TReal pX, TReal pY, TReal pZ) { AI_FORCE_INLINE void aiVector3t<TReal>::Set( TReal pX, TReal pY, TReal pZ) {
x = pX; y = pY; z = pZ; x = pX; y = pY; z = pZ;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE TReal aiVector3t<TReal>::SquareLength() const { AI_FORCE_INLINE TReal aiVector3t<TReal>::SquareLength() const {
return x*x + y*y + z*z; return x*x + y*y + z*z;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE TReal aiVector3t<TReal>::Length() const { AI_FORCE_INLINE TReal aiVector3t<TReal>::Length() const {
return std::sqrt( SquareLength()); return std::sqrt( SquareLength());
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::Normalize() { AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::Normalize() {
*this /= Length(); return *this; *this /= Length(); return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator += (const aiVector3t<TReal>& o) { AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator += (const aiVector3t<TReal>& o) {
x += o.x; y += o.y; z += o.z; return *this; x += o.x; y += o.y; z += o.z; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator -= (const aiVector3t<TReal>& o) { AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator -= (const aiVector3t<TReal>& o) {
x -= o.x; y -= o.y; z -= o.z; return *this; x -= o.x; y -= o.y; z -= o.z; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator *= (TReal f) { AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator *= (TReal f) {
x *= f; y *= f; z *= f; return *this; x *= f; y *= f; z *= f; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator /= (TReal f) { AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator /= (TReal f) {
x /= f; y /= f; z /= f; return *this; x /= f; y /= f; z /= f; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& mat){ AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& mat){
return(*this = mat * (*this)); return(*this = mat * (*this));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix4x4t<TReal>& mat){ AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix4x4t<TReal>& mat){
return(*this = mat * (*this)); return(*this = mat * (*this));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE TReal aiVector3t<TReal>::operator[](unsigned int i) const { AI_FORCE_INLINE TReal aiVector3t<TReal>::operator[](unsigned int i) const {
return *(&x + i); return *(&x + i);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE TReal& aiVector3t<TReal>::operator[](unsigned int i) { AI_FORCE_INLINE TReal& aiVector3t<TReal>::operator[](unsigned int i) {
return *(&x + i); return *(&x + i);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE bool aiVector3t<TReal>::operator== (const aiVector3t<TReal>& other) const { AI_FORCE_INLINE bool aiVector3t<TReal>::operator== (const aiVector3t<TReal>& other) const {
return x == other.x && y == other.y && z == other.z; return x == other.x && y == other.y && z == other.z;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE bool aiVector3t<TReal>::operator!= (const aiVector3t<TReal>& other) const { AI_FORCE_INLINE bool aiVector3t<TReal>::operator!= (const aiVector3t<TReal>& other) const {
return x != other.x || y != other.y || z != other.z; return x != other.x || y != other.y || z != other.z;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
AI_FORCE_INLINE bool aiVector3t<TReal>::Equal(const aiVector3t<TReal>& other, TReal epsilon) const { AI_FORCE_INLINE bool aiVector3t<TReal>::Equal(const aiVector3t<TReal>& other, TReal epsilon) const {
return return
std::abs(x - other.x) <= epsilon && std::abs(x - other.x) <= epsilon &&
std::abs(y - other.y) <= epsilon && std::abs(y - other.y) <= epsilon &&
std::abs(z - other.z) <= epsilon; std::abs(z - other.z) <= epsilon;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE bool aiVector3t<TReal>::operator < (const aiVector3t<TReal>& other) const { AI_FORCE_INLINE bool aiVector3t<TReal>::operator < (const aiVector3t<TReal>& other) const {
return x != other.x ? x < other.x : y != other.y ? y < other.y : z < other.z; return x != other.x ? x < other.x : y != other.y ? y < other.y : z < other.z;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE const aiVector3t<TReal> aiVector3t<TReal>::SymMul(const aiVector3t<TReal>& o) { AI_FORCE_INLINE const aiVector3t<TReal> aiVector3t<TReal>::SymMul(const aiVector3t<TReal>& o) {
return aiVector3t<TReal>(x*o.x,y*o.y,z*o.z); return aiVector3t<TReal>(x*o.x,y*o.y,z*o.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// symmetric addition // symmetric addition
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator + (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) { AI_FORCE_INLINE aiVector3t<TReal> operator + (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
return aiVector3t<TReal>( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z); return aiVector3t<TReal>( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// symmetric subtraction // symmetric subtraction
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator - (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) { AI_FORCE_INLINE aiVector3t<TReal> operator - (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
return aiVector3t<TReal>( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z); return aiVector3t<TReal>( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// scalar product // scalar product
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE TReal operator * (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) { AI_FORCE_INLINE TReal operator * (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z; return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// scalar multiplication // scalar multiplication
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator * ( TReal f, const aiVector3t<TReal>& v) { AI_FORCE_INLINE aiVector3t<TReal> operator * ( TReal f, const aiVector3t<TReal>& v) {
return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z); return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// and the other way around // and the other way around
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator * ( const aiVector3t<TReal>& v, TReal f) { AI_FORCE_INLINE aiVector3t<TReal> operator * ( const aiVector3t<TReal>& v, TReal f) {
return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z); return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// scalar division // scalar division
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, TReal f) { AI_FORCE_INLINE aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, TReal f) {
return v * (1/f); return v * (1/f);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// vector division // vector division
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, const aiVector3t<TReal>& v2) { AI_FORCE_INLINE aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, const aiVector3t<TReal>& v2) {
return aiVector3t<TReal>(v.x / v2.x,v.y / v2.y,v.z / v2.z); return aiVector3t<TReal>(v.x / v2.x,v.y / v2.y,v.z / v2.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// cross product // cross product
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator ^ ( const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) { AI_FORCE_INLINE aiVector3t<TReal> operator ^ ( const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
return aiVector3t<TReal>( v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x); return aiVector3t<TReal>( v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// vector negation // vector negation
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal> operator - ( const aiVector3t<TReal>& v) { AI_FORCE_INLINE aiVector3t<TReal> operator - ( const aiVector3t<TReal>& v) {
return aiVector3t<TReal>( -v.x, -v.y, -v.z); return aiVector3t<TReal>( -v.x, -v.y, -v.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------