556 lines
16 KiB
C++
556 lines
16 KiB
C++
/*
|
|
---------------------------------------------------------------------------
|
|
Open Asset Import Library (assimp)
|
|
---------------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2024, 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
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC system_header
|
|
#endif
|
|
|
|
// Some runtime headers
|
|
#include <limits.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
|
|
// Our compile configuration
|
|
#include <assimp/defs.h>
|
|
|
|
// Some types moved to separate header due to size of operators
|
|
#include <assimp/vector2.h>
|
|
#include <assimp/vector3.h>
|
|
#include <assimp/color4.h>
|
|
#include <assimp/matrix3x3.h>
|
|
#include <assimp/matrix4x4.h>
|
|
#include <assimp/quaternion.h>
|
|
|
|
typedef int32_t ai_int32;
|
|
typedef uint32_t ai_uint32;
|
|
|
|
#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() AI_NO_EXCEPT : 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() AI_NO_EXCEPT {}
|
|
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() AI_NO_EXCEPT : 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) {}
|
|
|
|
aiColor3D &operator=(const aiColor3D &o) {
|
|
r = o.r;
|
|
g = o.g;
|
|
b = o.b;
|
|
return *this;
|
|
}
|
|
|
|
/** 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() AI_NO_EXCEPT
|
|
: 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((ai_uint32)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 = (ai_uint32)pString.length();
|
|
memcpy(data, pString.c_str(), length);
|
|
data[length] = 0;
|
|
}
|
|
|
|
/** Copy a const char* to the aiString */
|
|
void Set(const char *sz) {
|
|
ai_int32 len = (ai_uint32)::strlen(sz);
|
|
if (len > (ai_int32)MAXLEN - 1) {
|
|
len = (ai_int32) MAXLEN - 1;
|
|
}
|
|
length = len;
|
|
memcpy(data, sz, len);
|
|
data[len] = 0;
|
|
}
|
|
|
|
/** Assignment operator */
|
|
aiString &operator=(const aiString &rOther) {
|
|
if (this == &rOther) {
|
|
return *this;
|
|
}
|
|
|
|
length = rOther.length;
|
|
if (length >(MAXLEN - 1)) {
|
|
length = (ai_int32) MAXLEN - 1;
|
|
}
|
|
|
|
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 ai_uint32 len = (ai_uint32)::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 multi-byte sequences! It's
|
|
* the number of bytes from the beginning of the string to its end.*/
|
|
ai_uint32 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() AI_NO_EXCEPT
|
|
: 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
|
|
|
|
/**
|
|
* @brief Type to store a in-memory data buffer.
|
|
*/
|
|
struct aiBuffer {
|
|
const char *data; ///< Begin poiner
|
|
const char *end; ///< End pointer
|
|
|
|
#ifdef __cplusplus
|
|
/// @brief The class constructor.
|
|
aiBuffer() :
|
|
data(nullptr), end(nullptr) {}
|
|
|
|
/// @brief The class destructor.
|
|
~aiBuffer() = default;
|
|
#endif //! __cplusplus
|
|
};
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif //! __cplusplus
|
|
|
|
// Include implementation files
|
|
#include "vector2.inl"
|
|
#include "vector3.inl"
|
|
#include "color4.inl"
|
|
#include "matrix3x3.inl"
|
|
#include "matrix4x4.inl"
|
|
#include "quaternion.inl"
|
|
|
|
#endif // AI_TYPES_H_INC
|