vrshoot

annotate libs/assimp/assimp/types.h @ 0:b2f14e535253

find changesets by author, revision, files, or words in the commit message
initial commit
author John Tsiombikas <nuclear@member.fsf.org>
date Sat, 01 Feb 2014 19:58:19 +0200
parents
children
rev   line source
nuclear@0 1 /*
nuclear@0 2 ---------------------------------------------------------------------------
nuclear@0 3 Open Asset Import Library (assimp)
nuclear@0 4 ---------------------------------------------------------------------------
nuclear@0 5
nuclear@0 6 Copyright (c) 2006-2012, assimp team
nuclear@0 7
nuclear@0 8 All rights reserved.
nuclear@0 9
nuclear@0 10 Redistribution and use of this software in source and binary forms,
nuclear@0 11 with or without modification, are permitted provided that the following
nuclear@0 12 conditions are met:
nuclear@0 13
nuclear@0 14 * Redistributions of source code must retain the above
nuclear@0 15 copyright notice, this list of conditions and the
nuclear@0 16 following disclaimer.
nuclear@0 17
nuclear@0 18 * Redistributions in binary form must reproduce the above
nuclear@0 19 copyright notice, this list of conditions and the
nuclear@0 20 following disclaimer in the documentation and/or other
nuclear@0 21 materials provided with the distribution.
nuclear@0 22
nuclear@0 23 * Neither the name of the assimp team, nor the names of its
nuclear@0 24 contributors may be used to endorse or promote products
nuclear@0 25 derived from this software without specific prior
nuclear@0 26 written permission of the assimp team.
nuclear@0 27
nuclear@0 28 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
nuclear@0 29 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
nuclear@0 30 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
nuclear@0 31 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
nuclear@0 32 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
nuclear@0 33 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
nuclear@0 34 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
nuclear@0 35 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
nuclear@0 36 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
nuclear@0 37 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
nuclear@0 38 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
nuclear@0 39 ---------------------------------------------------------------------------
nuclear@0 40 */
nuclear@0 41
nuclear@0 42 /** @file types.h
nuclear@0 43 * Basic data types and primitives, such as vectors or colors.
nuclear@0 44 */
nuclear@0 45 #ifndef AI_TYPES_H_INC
nuclear@0 46 #define AI_TYPES_H_INC
nuclear@0 47
nuclear@0 48 // Some runtime headers
nuclear@0 49 #include <sys/types.h>
nuclear@0 50 #include <memory.h>
nuclear@0 51 #include <math.h>
nuclear@0 52 #include <stddef.h>
nuclear@0 53 #include <limits.h>
nuclear@0 54
nuclear@0 55 // Our compile configuration
nuclear@0 56 #include "defs.h"
nuclear@0 57
nuclear@0 58 // Some types moved to separate header due to size of operators
nuclear@0 59 #include "vector3.h"
nuclear@0 60 #include "vector2.h"
nuclear@0 61 #include "color4.h"
nuclear@0 62 #include "matrix3x3.h"
nuclear@0 63 #include "matrix4x4.h"
nuclear@0 64 #include "quaternion.h"
nuclear@0 65
nuclear@0 66 #ifdef __cplusplus
nuclear@0 67 #include <new> // for std::nothrow_t
nuclear@0 68 #include <string> // for aiString::Set(const std::string&)
nuclear@0 69
nuclear@0 70 namespace Assimp {
nuclear@0 71 //! @cond never
nuclear@0 72 namespace Intern {
nuclear@0 73 // --------------------------------------------------------------------
nuclear@0 74 /** @brief Internal helper class to utilize our internal new/delete
nuclear@0 75 * routines for allocating object of this and derived classes.
nuclear@0 76 *
nuclear@0 77 * By doing this you can safely share class objects between Assimp
nuclear@0 78 * and the application - it works even over DLL boundaries. A good
nuclear@0 79 * example is the #IOSystem where the application allocates its custom
nuclear@0 80 * #IOSystem, then calls #Importer::SetIOSystem(). When the Importer
nuclear@0 81 * destructs, Assimp calls operator delete on the stored #IOSystem.
nuclear@0 82 * If it lies on a different heap than Assimp is working with,
nuclear@0 83 * the application is determined to crash.
nuclear@0 84 */
nuclear@0 85 // --------------------------------------------------------------------
nuclear@0 86 #ifndef SWIG
nuclear@0 87 struct ASSIMP_API AllocateFromAssimpHeap {
nuclear@0 88 // http://www.gotw.ca/publications/mill15.htm
nuclear@0 89
nuclear@0 90 // new/delete overload
nuclear@0 91 void *operator new ( size_t num_bytes) /* throw( std::bad_alloc ) */;
nuclear@0 92 void *operator new ( size_t num_bytes, const std::nothrow_t& ) throw();
nuclear@0 93 void operator delete ( void* data);
nuclear@0 94
nuclear@0 95 // array new/delete overload
nuclear@0 96 void *operator new[] ( size_t num_bytes) /* throw( std::bad_alloc ) */;
nuclear@0 97 void *operator new[] ( size_t num_bytes, const std::nothrow_t& ) throw();
nuclear@0 98 void operator delete[] ( void* data);
nuclear@0 99
nuclear@0 100 }; // struct AllocateFromAssimpHeap
nuclear@0 101 #endif
nuclear@0 102 } // namespace Intern
nuclear@0 103 //! @endcond
nuclear@0 104 } // namespace Assimp
nuclear@0 105
nuclear@0 106 extern "C" {
nuclear@0 107 #endif
nuclear@0 108
nuclear@0 109 /** Maximum dimension for strings, ASSIMP strings are zero terminated. */
nuclear@0 110 #ifdef __cplusplus
nuclear@0 111 const size_t MAXLEN = 1024;
nuclear@0 112 #else
nuclear@0 113 # define MAXLEN 1024
nuclear@0 114 #endif
nuclear@0 115
nuclear@0 116 #include "./Compiler/pushpack1.h"
nuclear@0 117
nuclear@0 118 // ----------------------------------------------------------------------------------
nuclear@0 119 /** Represents a plane in a three-dimensional, euclidean space
nuclear@0 120 */
nuclear@0 121 struct aiPlane
nuclear@0 122 {
nuclear@0 123 #ifdef __cplusplus
nuclear@0 124 aiPlane () : a(0.f), b(0.f), c(0.f), d(0.f) {}
nuclear@0 125 aiPlane (float _a, float _b, float _c, float _d)
nuclear@0 126 : a(_a), b(_b), c(_c), d(_d) {}
nuclear@0 127
nuclear@0 128 aiPlane (const aiPlane& o) : a(o.a), b(o.b), c(o.c), d(o.d) {}
nuclear@0 129
nuclear@0 130 #endif // !__cplusplus
nuclear@0 131
nuclear@0 132 //! Plane equation
nuclear@0 133 float a,b,c,d;
nuclear@0 134 } PACK_STRUCT; // !struct aiPlane
nuclear@0 135
nuclear@0 136 // ----------------------------------------------------------------------------------
nuclear@0 137 /** Represents a ray
nuclear@0 138 */
nuclear@0 139 struct aiRay
nuclear@0 140 {
nuclear@0 141 #ifdef __cplusplus
nuclear@0 142 aiRay () {}
nuclear@0 143 aiRay (const aiVector3D& _pos, const aiVector3D& _dir)
nuclear@0 144 : pos(_pos), dir(_dir) {}
nuclear@0 145
nuclear@0 146 aiRay (const aiRay& o) : pos (o.pos), dir (o.dir) {}
nuclear@0 147
nuclear@0 148 #endif // !__cplusplus
nuclear@0 149
nuclear@0 150 //! Position and direction of the ray
nuclear@0 151 C_STRUCT aiVector3D pos, dir;
nuclear@0 152 } PACK_STRUCT; // !struct aiRay
nuclear@0 153
nuclear@0 154 // ----------------------------------------------------------------------------------
nuclear@0 155 /** Represents a color in Red-Green-Blue space.
nuclear@0 156 */
nuclear@0 157 struct aiColor3D
nuclear@0 158 {
nuclear@0 159 #ifdef __cplusplus
nuclear@0 160 aiColor3D () : r(0.0f), g(0.0f), b(0.0f) {}
nuclear@0 161 aiColor3D (float _r, float _g, float _b) : r(_r), g(_g), b(_b) {}
nuclear@0 162 aiColor3D (float _r) : r(_r), g(_r), b(_r) {}
nuclear@0 163 aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {}
nuclear@0 164
nuclear@0 165 /** Component-wise comparison */
nuclear@0 166 // TODO: add epsilon?
nuclear@0 167 bool operator == (const aiColor3D& other) const
nuclear@0 168 {return r == other.r && g == other.g && b == other.b;}
nuclear@0 169
nuclear@0 170 /** Component-wise inverse comparison */
nuclear@0 171 // TODO: add epsilon?
nuclear@0 172 bool operator != (const aiColor3D& other) const
nuclear@0 173 {return r != other.r || g != other.g || b != other.b;}
nuclear@0 174
nuclear@0 175 /** Component-wise addition */
nuclear@0 176 aiColor3D operator+(const aiColor3D& c) const {
nuclear@0 177 return aiColor3D(r+c.r,g+c.g,b+c.b);
nuclear@0 178 }
nuclear@0 179
nuclear@0 180 /** Component-wise subtraction */
nuclear@0 181 aiColor3D operator-(const aiColor3D& c) const {
nuclear@0 182 return aiColor3D(r-c.r,g-c.g,b-c.b);
nuclear@0 183 }
nuclear@0 184
nuclear@0 185 /** Component-wise multiplication */
nuclear@0 186 aiColor3D operator*(const aiColor3D& c) const {
nuclear@0 187 return aiColor3D(r*c.r,g*c.g,b*c.b);
nuclear@0 188 }
nuclear@0 189
nuclear@0 190 /** Multiply with a scalar */
nuclear@0 191 aiColor3D operator*(float f) const {
nuclear@0 192 return aiColor3D(r*f,g*f,b*f);
nuclear@0 193 }
nuclear@0 194
nuclear@0 195 /** Access a specific color component */
nuclear@0 196 float operator[](unsigned int i) const {
nuclear@0 197 return *(&r + i);
nuclear@0 198 }
nuclear@0 199
nuclear@0 200 /** Access a specific color component */
nuclear@0 201 float& operator[](unsigned int i) {
nuclear@0 202 return *(&r + i);
nuclear@0 203 }
nuclear@0 204
nuclear@0 205 /** Check whether a color is black */
nuclear@0 206 bool IsBlack() const {
nuclear@0 207 static const float epsilon = 10e-3f;
nuclear@0 208 return fabs( r ) < epsilon && fabs( g ) < epsilon && fabs( b ) < epsilon;
nuclear@0 209 }
nuclear@0 210
nuclear@0 211 #endif // !__cplusplus
nuclear@0 212
nuclear@0 213 //! Red, green and blue color values
nuclear@0 214 float r, g, b;
nuclear@0 215 } PACK_STRUCT; // !struct aiColor3D
nuclear@0 216 #include "./Compiler/poppack1.h"
nuclear@0 217
nuclear@0 218 // ----------------------------------------------------------------------------------
nuclear@0 219 /** Represents an UTF-8 string, zero byte terminated.
nuclear@0 220 *
nuclear@0 221 * The character set of an aiString is explicitly defined to be UTF-8. This Unicode
nuclear@0 222 * transformation was chosen in the belief that most strings in 3d files are limited
nuclear@0 223 * to ASCII, thus the character set needed to be strictly ASCII compatible.
nuclear@0 224 *
nuclear@0 225 * Most text file loaders provide proper Unicode input file handling, special unicode
nuclear@0 226 * characters are correctly transcoded to UTF8 and are kept throughout the libraries'
nuclear@0 227 * import pipeline.
nuclear@0 228 *
nuclear@0 229 * For most applications, it will be absolutely sufficient to interpret the
nuclear@0 230 * aiString as ASCII data and work with it as one would work with a plain char*.
nuclear@0 231 * Windows users in need of proper support for i.e asian characters can use the
nuclear@0 232 * #MultiByteToWideChar(), #WideCharToMultiByte() WinAPI functionality to convert the
nuclear@0 233 * UTF-8 strings to their working character set (i.e. MBCS, WideChar).
nuclear@0 234 *
nuclear@0 235 * We use this representation instead of std::string to be C-compatible. The
nuclear@0 236 * (binary) length of such a string is limited to MAXLEN characters (including the
nuclear@0 237 * the terminating zero).
nuclear@0 238 */
nuclear@0 239 struct aiString
nuclear@0 240 {
nuclear@0 241 #ifdef __cplusplus
nuclear@0 242 /** Default constructor, the string is set to have zero length */
nuclear@0 243 aiString() :
nuclear@0 244 length(0)
nuclear@0 245 {
nuclear@0 246 data[0] = '\0';
nuclear@0 247
nuclear@0 248 #ifdef _DEBUG
nuclear@0 249 // Debug build: overwrite the string on its full length with ESC (27)
nuclear@0 250 memset(data+1,27,MAXLEN-1);
nuclear@0 251 #endif
nuclear@0 252 }
nuclear@0 253
nuclear@0 254 /** Copy constructor */
nuclear@0 255 aiString(const aiString& rOther) :
nuclear@0 256 length(rOther.length)
nuclear@0 257 {
nuclear@0 258 // Crop the string to the maximum length
nuclear@0 259 length = length>=MAXLEN?MAXLEN-1:length;
nuclear@0 260 memcpy( data, rOther.data, length);
nuclear@0 261 data[length] = '\0';
nuclear@0 262 }
nuclear@0 263
nuclear@0 264 /** Constructor from std::string */
nuclear@0 265 explicit aiString(const std::string& pString) :
nuclear@0 266 length(pString.length())
nuclear@0 267 {
nuclear@0 268 length = length>=MAXLEN?MAXLEN-1:length;
nuclear@0 269 memcpy( data, pString.c_str(), length);
nuclear@0 270 data[length] = '\0';
nuclear@0 271 }
nuclear@0 272
nuclear@0 273 /** Copy a std::string to the aiString */
nuclear@0 274 void Set( const std::string& pString) {
nuclear@0 275 if( pString.length() > MAXLEN - 1) {
nuclear@0 276 return;
nuclear@0 277 }
nuclear@0 278 length = pString.length();
nuclear@0 279 memcpy( data, pString.c_str(), length);
nuclear@0 280 data[length] = 0;
nuclear@0 281 }
nuclear@0 282
nuclear@0 283 /** Copy a const char* to the aiString */
nuclear@0 284 void Set( const char* sz) {
nuclear@0 285 const size_t len = ::strlen(sz);
nuclear@0 286 if( len > MAXLEN - 1) {
nuclear@0 287 return;
nuclear@0 288 }
nuclear@0 289 length = len;
nuclear@0 290 memcpy( data, sz, len);
nuclear@0 291 data[len] = 0;
nuclear@0 292 }
nuclear@0 293
nuclear@0 294 /** Assign a const char* to the string */
nuclear@0 295 aiString& operator = (const char* sz) {
nuclear@0 296 Set(sz);
nuclear@0 297 return *this;
nuclear@0 298 }
nuclear@0 299
nuclear@0 300 /** Assign a cstd::string to the string */
nuclear@0 301 aiString& operator = ( const std::string& pString) {
nuclear@0 302 Set(pString);
nuclear@0 303 return *this;
nuclear@0 304 }
nuclear@0 305
nuclear@0 306 /** Comparison operator */
nuclear@0 307 bool operator==(const aiString& other) const {
nuclear@0 308 return (length == other.length && 0 == memcmp(data,other.data,length));
nuclear@0 309 }
nuclear@0 310
nuclear@0 311 /** Inverse comparison operator */
nuclear@0 312 bool operator!=(const aiString& other) const {
nuclear@0 313 return (length != other.length || 0 != memcmp(data,other.data,length));
nuclear@0 314 }
nuclear@0 315
nuclear@0 316 /** Append a string to the string */
nuclear@0 317 void Append (const char* app) {
nuclear@0 318 const size_t len = ::strlen(app);
nuclear@0 319 if (!len) {
nuclear@0 320 return;
nuclear@0 321 }
nuclear@0 322 if (length + len >= MAXLEN) {
nuclear@0 323 return;
nuclear@0 324 }
nuclear@0 325
nuclear@0 326 memcpy(&data[length],app,len+1);
nuclear@0 327 length += len;
nuclear@0 328 }
nuclear@0 329
nuclear@0 330 /** Clear the string - reset its length to zero */
nuclear@0 331 void Clear () {
nuclear@0 332 length = 0;
nuclear@0 333 data[0] = '\0';
nuclear@0 334
nuclear@0 335 #ifdef _DEBUG
nuclear@0 336 // Debug build: overwrite the string on its full length with ESC (27)
nuclear@0 337 memset(data+1,27,MAXLEN-1);
nuclear@0 338 #endif
nuclear@0 339 }
nuclear@0 340
nuclear@0 341 /** Returns a pointer to the underlying zero-terminated array of characters */
nuclear@0 342 const char* C_Str() const {
nuclear@0 343 return data;
nuclear@0 344 }
nuclear@0 345
nuclear@0 346 #endif // !__cplusplus
nuclear@0 347
nuclear@0 348 /** Binary length of the string excluding the terminal 0. This is NOT the
nuclear@0 349 * logical length of strings containing UTF-8 multibyte sequences! It's
nuclear@0 350 * the number of bytes from the beginning of the string to its end.*/
nuclear@0 351 size_t length;
nuclear@0 352
nuclear@0 353 /** String buffer. Size limit is MAXLEN */
nuclear@0 354 char data[MAXLEN];
nuclear@0 355 } ; // !struct aiString
nuclear@0 356
nuclear@0 357
nuclear@0 358 // ----------------------------------------------------------------------------------
nuclear@0 359 /** Standard return type for some library functions.
nuclear@0 360 * Rarely used, and if, mostly in the C API.
nuclear@0 361 */
nuclear@0 362 enum aiReturn
nuclear@0 363 {
nuclear@0 364 /** Indicates that a function was successful */
nuclear@0 365 aiReturn_SUCCESS = 0x0,
nuclear@0 366
nuclear@0 367 /** Indicates that a function failed */
nuclear@0 368 aiReturn_FAILURE = -0x1,
nuclear@0 369
nuclear@0 370 /** Indicates that not enough memory was available
nuclear@0 371 * to perform the requested operation
nuclear@0 372 */
nuclear@0 373 aiReturn_OUTOFMEMORY = -0x3,
nuclear@0 374
nuclear@0 375 /** @cond never
nuclear@0 376 * Force 32-bit size enum
nuclear@0 377 */
nuclear@0 378 _AI_ENFORCE_ENUM_SIZE = 0x7fffffff
nuclear@0 379 }; // !enum aiReturn
nuclear@0 380
nuclear@0 381 // just for backwards compatibility, don't use these constants anymore
nuclear@0 382 #define AI_SUCCESS aiReturn_SUCCESS
nuclear@0 383 #define AI_FAILURE aiReturn_FAILURE
nuclear@0 384 #define AI_OUTOFMEMORY aiReturn_OUTOFMEMORY
nuclear@0 385
nuclear@0 386 // ----------------------------------------------------------------------------------
nuclear@0 387 /** Seek origins (for the virtual file system API).
nuclear@0 388 * Much cooler than using SEEK_SET, SEEK_CUR or SEEK_END.
nuclear@0 389 */
nuclear@0 390 enum aiOrigin
nuclear@0 391 {
nuclear@0 392 /** Beginning of the file */
nuclear@0 393 aiOrigin_SET = 0x0,
nuclear@0 394
nuclear@0 395 /** Current position of the file pointer */
nuclear@0 396 aiOrigin_CUR = 0x1,
nuclear@0 397
nuclear@0 398 /** End of the file, offsets must be negative */
nuclear@0 399 aiOrigin_END = 0x2,
nuclear@0 400
nuclear@0 401 /** @cond never
nuclear@0 402 * Force 32-bit size enum
nuclear@0 403 */
nuclear@0 404 _AI_ORIGIN_ENFORCE_ENUM_SIZE = 0x7fffffff
nuclear@0 405 }; // !enum aiOrigin
nuclear@0 406
nuclear@0 407 // ----------------------------------------------------------------------------------
nuclear@0 408 /** @brief Enumerates predefined log streaming destinations.
nuclear@0 409 * Logging to these streams can be enabled with a single call to
nuclear@0 410 * #LogStream::createDefaultStream or #aiAttachPredefinedLogStream(),
nuclear@0 411 * respectively.
nuclear@0 412 */
nuclear@0 413 enum aiDefaultLogStream
nuclear@0 414 {
nuclear@0 415 /** Stream the log to a file */
nuclear@0 416 aiDefaultLogStream_FILE = 0x1,
nuclear@0 417
nuclear@0 418 /** Stream the log to std::cout */
nuclear@0 419 aiDefaultLogStream_STDOUT = 0x2,
nuclear@0 420
nuclear@0 421 /** Stream the log to std::cerr */
nuclear@0 422 aiDefaultLogStream_STDERR = 0x4,
nuclear@0 423
nuclear@0 424 /** MSVC only: Stream the log the the debugger
nuclear@0 425 * (this relies on OutputDebugString from the Win32 SDK)
nuclear@0 426 */
nuclear@0 427 aiDefaultLogStream_DEBUGGER = 0x8,
nuclear@0 428
nuclear@0 429 /** @cond never
nuclear@0 430 * Force 32-bit size enum
nuclear@0 431 */
nuclear@0 432 _AI_DLS_ENFORCE_ENUM_SIZE = 0x7fffffff
nuclear@0 433 }; // !enum aiDefaultLogStream
nuclear@0 434
nuclear@0 435 // just for backwards compatibility, don't use these constants anymore
nuclear@0 436 #define DLS_FILE aiDefaultLogStream_FILE
nuclear@0 437 #define DLS_STDOUT aiDefaultLogStream_STDOUT
nuclear@0 438 #define DLS_STDERR aiDefaultLogStream_STDERR
nuclear@0 439 #define DLS_DEBUGGER aiDefaultLogStream_DEBUGGER
nuclear@0 440
nuclear@0 441 // ----------------------------------------------------------------------------------
nuclear@0 442 /** Stores the memory requirements for different components (e.g. meshes, materials,
nuclear@0 443 * animations) of an import. All sizes are in bytes.
nuclear@0 444 * @see Importer::GetMemoryRequirements()
nuclear@0 445 */
nuclear@0 446 struct aiMemoryInfo
nuclear@0 447 {
nuclear@0 448 #ifdef __cplusplus
nuclear@0 449
nuclear@0 450 /** Default constructor */
nuclear@0 451 aiMemoryInfo()
nuclear@0 452 : textures (0)
nuclear@0 453 , materials (0)
nuclear@0 454 , meshes (0)
nuclear@0 455 , nodes (0)
nuclear@0 456 , animations (0)
nuclear@0 457 , cameras (0)
nuclear@0 458 , lights (0)
nuclear@0 459 , total (0)
nuclear@0 460 {}
nuclear@0 461
nuclear@0 462 #endif
nuclear@0 463
nuclear@0 464 /** Storage allocated for texture data */
nuclear@0 465 unsigned int textures;
nuclear@0 466
nuclear@0 467 /** Storage allocated for material data */
nuclear@0 468 unsigned int materials;
nuclear@0 469
nuclear@0 470 /** Storage allocated for mesh data */
nuclear@0 471 unsigned int meshes;
nuclear@0 472
nuclear@0 473 /** Storage allocated for node data */
nuclear@0 474 unsigned int nodes;
nuclear@0 475
nuclear@0 476 /** Storage allocated for animation data */
nuclear@0 477 unsigned int animations;
nuclear@0 478
nuclear@0 479 /** Storage allocated for camera data */
nuclear@0 480 unsigned int cameras;
nuclear@0 481
nuclear@0 482 /** Storage allocated for light data */
nuclear@0 483 unsigned int lights;
nuclear@0 484
nuclear@0 485 /** Total storage allocated for the full import. */
nuclear@0 486 unsigned int total;
nuclear@0 487 }; // !struct aiMemoryInfo
nuclear@0 488
nuclear@0 489 #ifdef __cplusplus
nuclear@0 490 }
nuclear@0 491 #endif //! __cplusplus
nuclear@0 492
nuclear@0 493 // Include implementation files
nuclear@0 494 #include "vector2.inl"
nuclear@0 495 #include "vector3.inl"
nuclear@0 496 #include "color4.inl"
nuclear@0 497 #include "quaternion.inl"
nuclear@0 498 #include "matrix3x3.inl"
nuclear@0 499 #include "matrix4x4.inl"
nuclear@0 500 #endif