533 lines
16 KiB
C++
533 lines
16 KiB
C++
/*
|
|
---------------------------------------------------------------------------
|
|
Open Asset Import Library (assimp)
|
|
---------------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2018, assimp team
|
|
|
|
|
|
|
|
All rights reserved.
|
|
|
|
Redistribution and use of this software in source and binary forms,
|
|
with or without modification, are permitted provided that the following
|
|
conditions are met:
|
|
|
|
* Redistributions of source code must retain the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer in the documentation and/or other
|
|
materials provided with the distribution.
|
|
|
|
* Neither the name of the assimp team, nor the names of its
|
|
contributors may be used to endorse or promote products
|
|
derived from this software without specific prior
|
|
written permission of the assimp team.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
---------------------------------------------------------------------------
|
|
*/
|
|
|
|
/** @file types.h
|
|
* Basic data types and primitives, such as vectors or colors.
|
|
*/
|
|
#pragma once
|
|
#ifndef AI_TYPES_H_INC
|
|
#define AI_TYPES_H_INC
|
|
|
|
// Some runtime headers
|
|
#include <sys/types.h>
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
#include <limits.h>
|
|
|
|
// Our compile configuration
|
|
#include "defs.h"
|
|
|
|
// Some types moved to separate header due to size of operators
|
|
#include "vector3.h"
|
|
#include "vector2.h"
|
|
#include "color4.h"
|
|
#include "matrix3x3.h"
|
|
#include "matrix4x4.h"
|
|
#include "quaternion.h"
|
|
|
|
#ifdef __cplusplus
|
|
#include <cstring>
|
|
#include <new> // for std::nothrow_t
|
|
#include <string> // for aiString::Set(const std::string&)
|
|
|
|
namespace Assimp {
|
|
//! @cond never
|
|
namespace Intern {
|
|
// --------------------------------------------------------------------
|
|
/** @brief Internal helper class to utilize our internal new/delete
|
|
* routines for allocating object of this and derived classes.
|
|
*
|
|
* By doing this you can safely share class objects between Assimp
|
|
* and the application - it works even over DLL boundaries. A good
|
|
* example is the #IOSystem where the application allocates its custom
|
|
* #IOSystem, then calls #Importer::SetIOSystem(). When the Importer
|
|
* destructs, Assimp calls operator delete on the stored #IOSystem.
|
|
* If it lies on a different heap than Assimp is working with,
|
|
* the application is determined to crash.
|
|
*/
|
|
// --------------------------------------------------------------------
|
|
#ifndef SWIG
|
|
struct ASSIMP_API AllocateFromAssimpHeap {
|
|
// http://www.gotw.ca/publications/mill15.htm
|
|
|
|
// new/delete overload
|
|
void *operator new ( size_t num_bytes) /* throw( std::bad_alloc ) */;
|
|
void *operator new ( size_t num_bytes, const std::nothrow_t& ) throw();
|
|
void operator delete ( void* data);
|
|
|
|
// array new/delete overload
|
|
void *operator new[] ( size_t num_bytes) /* throw( std::bad_alloc ) */;
|
|
void *operator new[] ( size_t num_bytes, const std::nothrow_t& ) throw();
|
|
void operator delete[] ( void* data);
|
|
|
|
}; // struct AllocateFromAssimpHeap
|
|
#endif
|
|
} // namespace Intern
|
|
//! @endcond
|
|
} // namespace Assimp
|
|
|
|
extern "C" {
|
|
#endif
|
|
|
|
/** Maximum dimension for strings, ASSIMP strings are zero terminated. */
|
|
#ifdef __cplusplus
|
|
static const size_t MAXLEN = 1024;
|
|
#else
|
|
# define MAXLEN 1024
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
/** Represents a plane in a three-dimensional, euclidean space
|
|
*/
|
|
struct aiPlane
|
|
{
|
|
#ifdef __cplusplus
|
|
aiPlane () : a(0.f), b(0.f), c(0.f), d(0.f) {}
|
|
aiPlane (ai_real _a, ai_real _b, ai_real _c, ai_real _d)
|
|
: a(_a), b(_b), c(_c), d(_d) {}
|
|
|
|
aiPlane (const aiPlane& o) : a(o.a), b(o.b), c(o.c), d(o.d) {}
|
|
|
|
#endif // !__cplusplus
|
|
|
|
//! Plane equation
|
|
ai_real a,b,c,d;
|
|
}; // !struct aiPlane
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
/** Represents a ray
|
|
*/
|
|
struct aiRay
|
|
{
|
|
#ifdef __cplusplus
|
|
aiRay () {}
|
|
aiRay (const aiVector3D& _pos, const aiVector3D& _dir)
|
|
: pos(_pos), dir(_dir) {}
|
|
|
|
aiRay (const aiRay& o) : pos (o.pos), dir (o.dir) {}
|
|
|
|
#endif // !__cplusplus
|
|
|
|
//! Position and direction of the ray
|
|
C_STRUCT aiVector3D pos, dir;
|
|
}; // !struct aiRay
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
/** Represents a color in Red-Green-Blue space.
|
|
*/
|
|
struct aiColor3D
|
|
{
|
|
#ifdef __cplusplus
|
|
aiColor3D () : r(0.0f), g(0.0f), b(0.0f) {}
|
|
aiColor3D (ai_real _r, ai_real _g, ai_real _b) : r(_r), g(_g), b(_b) {}
|
|
explicit aiColor3D (ai_real _r) : r(_r), g(_r), b(_r) {}
|
|
aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {}
|
|
|
|
/** Component-wise comparison */
|
|
// TODO: add epsilon?
|
|
bool operator == (const aiColor3D& other) const
|
|
{return r == other.r && g == other.g && b == other.b;}
|
|
|
|
/** Component-wise inverse comparison */
|
|
// TODO: add epsilon?
|
|
bool operator != (const aiColor3D& other) const
|
|
{return r != other.r || g != other.g || b != other.b;}
|
|
|
|
/** Component-wise comparison */
|
|
// TODO: add epsilon?
|
|
bool operator < (const aiColor3D& other) const {
|
|
return r < other.r || ( r == other.r && (g < other.g || (g == other.g && b < other.b ) ) );
|
|
}
|
|
|
|
/** Component-wise addition */
|
|
aiColor3D operator+(const aiColor3D& c) const {
|
|
return aiColor3D(r+c.r,g+c.g,b+c.b);
|
|
}
|
|
|
|
/** Component-wise subtraction */
|
|
aiColor3D operator-(const aiColor3D& c) const {
|
|
return aiColor3D(r-c.r,g-c.g,b-c.b);
|
|
}
|
|
|
|
/** Component-wise multiplication */
|
|
aiColor3D operator*(const aiColor3D& c) const {
|
|
return aiColor3D(r*c.r,g*c.g,b*c.b);
|
|
}
|
|
|
|
/** Multiply with a scalar */
|
|
aiColor3D operator*(ai_real f) const {
|
|
return aiColor3D(r*f,g*f,b*f);
|
|
}
|
|
|
|
/** Access a specific color component */
|
|
ai_real operator[](unsigned int i) const {
|
|
return *(&r + i);
|
|
}
|
|
|
|
/** Access a specific color component */
|
|
ai_real& operator[](unsigned int i) {
|
|
if ( 0 == i ) {
|
|
return r;
|
|
} else if ( 1 == i ) {
|
|
return g;
|
|
} else if ( 2 == i ) {
|
|
return b;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
/** Check whether a color is black */
|
|
bool IsBlack() const {
|
|
static const ai_real epsilon = ai_real(10e-3);
|
|
return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon;
|
|
}
|
|
|
|
#endif // !__cplusplus
|
|
|
|
//! Red, green and blue color values
|
|
ai_real r, g, b;
|
|
}; // !struct aiColor3D
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
/** Represents an UTF-8 string, zero byte terminated.
|
|
*
|
|
* The character set of an aiString is explicitly defined to be UTF-8. This Unicode
|
|
* transformation was chosen in the belief that most strings in 3d files are limited
|
|
* to ASCII, thus the character set needed to be strictly ASCII compatible.
|
|
*
|
|
* Most text file loaders provide proper Unicode input file handling, special unicode
|
|
* characters are correctly transcoded to UTF8 and are kept throughout the libraries'
|
|
* import pipeline.
|
|
*
|
|
* For most applications, it will be absolutely sufficient to interpret the
|
|
* aiString as ASCII data and work with it as one would work with a plain char*.
|
|
* Windows users in need of proper support for i.e asian characters can use the
|
|
* MultiByteToWideChar(), WideCharToMultiByte() WinAPI functionality to convert the
|
|
* UTF-8 strings to their working character set (i.e. MBCS, WideChar).
|
|
*
|
|
* We use this representation instead of std::string to be C-compatible. The
|
|
* (binary) length of such a string is limited to MAXLEN characters (including the
|
|
* the terminating zero).
|
|
*/
|
|
struct aiString
|
|
{
|
|
#ifdef __cplusplus
|
|
/** Default constructor, the string is set to have zero length */
|
|
aiString() :
|
|
length(0)
|
|
{
|
|
data[0] = '\0';
|
|
|
|
#ifdef ASSIMP_BUILD_DEBUG
|
|
// Debug build: overwrite the string on its full length with ESC (27)
|
|
memset(data+1,27,MAXLEN-1);
|
|
#endif
|
|
}
|
|
|
|
/** Copy constructor */
|
|
aiString(const aiString& rOther) :
|
|
length(rOther.length)
|
|
{
|
|
// Crop the string to the maximum length
|
|
length = length>=MAXLEN?MAXLEN-1:length;
|
|
memcpy( data, rOther.data, length);
|
|
data[length] = '\0';
|
|
}
|
|
|
|
/** Constructor from std::string */
|
|
explicit aiString(const std::string& pString) :
|
|
length(pString.length())
|
|
{
|
|
length = length>=MAXLEN?MAXLEN-1:length;
|
|
memcpy( data, pString.c_str(), length);
|
|
data[length] = '\0';
|
|
}
|
|
|
|
/** Copy a std::string to the aiString */
|
|
void Set( const std::string& pString) {
|
|
if( pString.length() > MAXLEN - 1) {
|
|
return;
|
|
}
|
|
length = pString.length();
|
|
memcpy( data, pString.c_str(), length);
|
|
data[length] = 0;
|
|
}
|
|
|
|
/** Copy a const char* to the aiString */
|
|
void Set( const char* sz) {
|
|
const size_t len = ::strlen(sz);
|
|
if( len > MAXLEN - 1) {
|
|
return;
|
|
}
|
|
length = len;
|
|
memcpy( data, sz, len);
|
|
data[len] = 0;
|
|
}
|
|
|
|
|
|
/** Assigment operator */
|
|
aiString& operator = (const aiString &rOther) {
|
|
if (this == &rOther) {
|
|
return *this;
|
|
}
|
|
|
|
length = rOther.length;;
|
|
memcpy( data, rOther.data, length);
|
|
data[length] = '\0';
|
|
return *this;
|
|
}
|
|
|
|
|
|
/** Assign a const char* to the string */
|
|
aiString& operator = (const char* sz) {
|
|
Set(sz);
|
|
return *this;
|
|
}
|
|
|
|
/** Assign a cstd::string to the string */
|
|
aiString& operator = ( const std::string& pString) {
|
|
Set(pString);
|
|
return *this;
|
|
}
|
|
|
|
/** Comparison operator */
|
|
bool operator==(const aiString& other) const {
|
|
return (length == other.length && 0 == memcmp(data,other.data,length));
|
|
}
|
|
|
|
/** Inverse comparison operator */
|
|
bool operator!=(const aiString& other) const {
|
|
return (length != other.length || 0 != memcmp(data,other.data,length));
|
|
}
|
|
|
|
/** Append a string to the string */
|
|
void Append (const char* app) {
|
|
const size_t len = ::strlen(app);
|
|
if (!len) {
|
|
return;
|
|
}
|
|
if (length + len >= MAXLEN) {
|
|
return;
|
|
}
|
|
|
|
memcpy(&data[length],app,len+1);
|
|
length += len;
|
|
}
|
|
|
|
/** Clear the string - reset its length to zero */
|
|
void Clear () {
|
|
length = 0;
|
|
data[0] = '\0';
|
|
|
|
#ifdef ASSIMP_BUILD_DEBUG
|
|
// Debug build: overwrite the string on its full length with ESC (27)
|
|
memset(data+1,27,MAXLEN-1);
|
|
#endif
|
|
}
|
|
|
|
/** Returns a pointer to the underlying zero-terminated array of characters */
|
|
const char* C_Str() const {
|
|
return data;
|
|
}
|
|
|
|
#endif // !__cplusplus
|
|
|
|
/** Binary length of the string excluding the terminal 0. This is NOT the
|
|
* logical length of strings containing UTF-8 multibyte sequences! It's
|
|
* the number of bytes from the beginning of the string to its end.*/
|
|
size_t length;
|
|
|
|
/** String buffer. Size limit is MAXLEN */
|
|
char data[MAXLEN];
|
|
} ; // !struct aiString
|
|
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
/** Standard return type for some library functions.
|
|
* Rarely used, and if, mostly in the C API.
|
|
*/
|
|
typedef enum aiReturn
|
|
{
|
|
/** Indicates that a function was successful */
|
|
aiReturn_SUCCESS = 0x0,
|
|
|
|
/** Indicates that a function failed */
|
|
aiReturn_FAILURE = -0x1,
|
|
|
|
/** Indicates that not enough memory was available
|
|
* to perform the requested operation
|
|
*/
|
|
aiReturn_OUTOFMEMORY = -0x3,
|
|
|
|
/** @cond never
|
|
* Force 32-bit size enum
|
|
*/
|
|
_AI_ENFORCE_ENUM_SIZE = 0x7fffffff
|
|
|
|
/// @endcond
|
|
} aiReturn; // !enum aiReturn
|
|
|
|
// just for backwards compatibility, don't use these constants anymore
|
|
#define AI_SUCCESS aiReturn_SUCCESS
|
|
#define AI_FAILURE aiReturn_FAILURE
|
|
#define AI_OUTOFMEMORY aiReturn_OUTOFMEMORY
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
/** Seek origins (for the virtual file system API).
|
|
* Much cooler than using SEEK_SET, SEEK_CUR or SEEK_END.
|
|
*/
|
|
enum aiOrigin
|
|
{
|
|
/** Beginning of the file */
|
|
aiOrigin_SET = 0x0,
|
|
|
|
/** Current position of the file pointer */
|
|
aiOrigin_CUR = 0x1,
|
|
|
|
/** End of the file, offsets must be negative */
|
|
aiOrigin_END = 0x2,
|
|
|
|
/** @cond never
|
|
* Force 32-bit size enum
|
|
*/
|
|
_AI_ORIGIN_ENFORCE_ENUM_SIZE = 0x7fffffff
|
|
|
|
/// @endcond
|
|
}; // !enum aiOrigin
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
/** @brief Enumerates predefined log streaming destinations.
|
|
* Logging to these streams can be enabled with a single call to
|
|
* #LogStream::createDefaultStream.
|
|
*/
|
|
enum aiDefaultLogStream
|
|
{
|
|
/** Stream the log to a file */
|
|
aiDefaultLogStream_FILE = 0x1,
|
|
|
|
/** Stream the log to std::cout */
|
|
aiDefaultLogStream_STDOUT = 0x2,
|
|
|
|
/** Stream the log to std::cerr */
|
|
aiDefaultLogStream_STDERR = 0x4,
|
|
|
|
/** MSVC only: Stream the log the the debugger
|
|
* (this relies on OutputDebugString from the Win32 SDK)
|
|
*/
|
|
aiDefaultLogStream_DEBUGGER = 0x8,
|
|
|
|
/** @cond never
|
|
* Force 32-bit size enum
|
|
*/
|
|
_AI_DLS_ENFORCE_ENUM_SIZE = 0x7fffffff
|
|
/// @endcond
|
|
}; // !enum aiDefaultLogStream
|
|
|
|
// just for backwards compatibility, don't use these constants anymore
|
|
#define DLS_FILE aiDefaultLogStream_FILE
|
|
#define DLS_STDOUT aiDefaultLogStream_STDOUT
|
|
#define DLS_STDERR aiDefaultLogStream_STDERR
|
|
#define DLS_DEBUGGER aiDefaultLogStream_DEBUGGER
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
/** Stores the memory requirements for different components (e.g. meshes, materials,
|
|
* animations) of an import. All sizes are in bytes.
|
|
* @see Importer::GetMemoryRequirements()
|
|
*/
|
|
struct aiMemoryInfo
|
|
{
|
|
#ifdef __cplusplus
|
|
|
|
/** Default constructor */
|
|
aiMemoryInfo()
|
|
: textures (0)
|
|
, materials (0)
|
|
, meshes (0)
|
|
, nodes (0)
|
|
, animations (0)
|
|
, cameras (0)
|
|
, lights (0)
|
|
, total (0)
|
|
{}
|
|
|
|
#endif
|
|
|
|
/** Storage allocated for texture data */
|
|
unsigned int textures;
|
|
|
|
/** Storage allocated for material data */
|
|
unsigned int materials;
|
|
|
|
/** Storage allocated for mesh data */
|
|
unsigned int meshes;
|
|
|
|
/** Storage allocated for node data */
|
|
unsigned int nodes;
|
|
|
|
/** Storage allocated for animation data */
|
|
unsigned int animations;
|
|
|
|
/** Storage allocated for camera data */
|
|
unsigned int cameras;
|
|
|
|
/** Storage allocated for light data */
|
|
unsigned int lights;
|
|
|
|
/** Total storage allocated for the full import. */
|
|
unsigned int total;
|
|
}; // !struct aiMemoryInfo
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif //! __cplusplus
|
|
|
|
// Include implementation files
|
|
#include "vector2.inl"
|
|
#include "vector3.inl"
|
|
#include "color4.inl"
|
|
#include "quaternion.inl"
|
|
#include "matrix3x3.inl"
|
|
#include "matrix4x4.inl"
|
|
|
|
#endif // AI_TYPES_H_INC
|