Assimp: assimp - Open Asset Import Library

Assimp v2.0 (November 2010)
  • Main Page
  • Related Pages
  • Namespaces
  • Classes
  • Files
assimp - Open Asset Import Library

Introduction

assimp is a library to load and process geometric scenes from various data formats. It is tailored at typical game scenarios by supporting a node hierarchy, static or skinned meshes, materials, bone animations and potential texture data. The library is *not* designed for speed, it is primarily useful for importing assets from various sources once and storing it in a engine-specific format for easy and fast every-day-loading. assimp is also able to apply various post processing steps to the imported data such as conversion to indexed meshes, calculation of normals or tangents/bitangents or conversion from right-handed to left-handed coordinate systems.

assimp currently supports the following file formats (note that some loaders lack some features of their formats because some file formats contain data not supported by assimp, some stuff would require so much conversion work that it has not been implemented yet and some (most ...) formats lack proper specifications):

Collada ( *.dae;*.xml )
Blender ( *.blend ) 3
Biovision BVH ( *.bvh )
3D Studio Max 3DS ( *.3ds )
3D Studio Max ASE ( *.ase )
Wavefront Object ( *.obj )
Stanford Polygon Library ( *.ply )
AutoCAD DXF ( *.dxf )
IFC-STEP ( *.ifc )
Neutral File Format ( *.nff )
Sense8 WorldToolkit ( *.nff )
Valve Model ( *.smd,*.vta ) 3
Quake I ( *.mdl )
Quake II ( *.md2 )
Quake III ( *.md3 )
Quake 3 BSP ( *.pk3 ) 1
RtCW ( *.mdc )
Doom 3 ( *.md5mesh;*.md5anim;*.md5camera )
DirectX X ( *.x ).
Quick3D ( *.q3o;*q3s ).
Raw Triangles ( *.raw ).
AC3D ( *.ac ).
Stereolithography ( *.stl ).
Autodesk DXF ( *.dxf ).
Irrlicht Mesh ( *.irrmesh;*.xml ).
Irrlicht Scene ( *.irr;*.xml ).
Object File Format ( *.off ).
Terragen Terrain ( *.ter )
3D GameStudio Model ( *.mdl )
3D GameStudio Terrain ( *.hmp )
Ogre (*.mesh.xml, *.skeleton.xml, *.material)3
Milkshape 3D ( *.ms3d )
LightWave Model ( *.lwo )
LightWave Scene ( *.lws )
Modo Model ( *.lxo )
CharacterStudio Motion ( *.csm )
Stanford Ply ( *.ply )
TrueSpace ( *.cob, *.scn )2

 See the Importer Notes Page for informations, what a specific importer can do and what not. Note that although this paper claims to be the official documentation, http://assimp.sourceforge.net/main_features_formats.html
is usually the most up-to-date list of file formats supported by the library.

1: Experimental loaders
2: Indicates very limited support - many of the format's features don't map to Assimp's data structures.
3: These formats support animations, but assimp doesn't yet support them (or they're buggy)

assimp is independent of the Operating System by nature, providing a C++ interface for easy integration with game engines and a C interface to allow bindings to other programming languages. At the moment the library runs on any little-endian platform including X86/Windows/Linux/Mac and X64/Windows/Linux/Mac. Special attention was paid to keep the library as free as possible from dependencies.

Big endian systems such as PPC-Macs or PPC-Linux systems are not officially supported at the moment. However, most formats handle the required endian conversion correctly, so large parts of the library should work.

The assimp linker library and viewer application are provided under the BSD 3-clause license. This basically means that you are free to use it in open- or closed-source projects, for commercial or non-commercial purposes as you like as long as you retain the license informations and take own responsibility for what you do with it. For details see the LICENSE file.

You can find test models for almost all formats in the <assimp_root>/test/models directory. Beware, they're *free*, but not all of them are *open-source*. If there's an accompagning '<file>.txt' file don't forget to read it.

Installation

assimp can be used in two ways: linking against the pre-built libraries or building the library on your own. The former option is the easiest, but the assimp distribution contains pre-built libraries only for Visual C++ 2005 and 2008. For other compilers you'll have to build assimp for yourself. Which is hopefully as hassle-free as the other way, but needs a bit more work. Both ways are described at the Installation page.

Usage

When you're done integrating the library into your IDE / project, you can now start using it. There are two separate interfaces by which you can access the library: a C++ interface and a C interface using flat functions. While the former is easier to handle, the latter also forms a point where other programming languages can connect to. Upto the moment, though, there are no bindings for any other language provided. Have a look at the Usage page for a detailed explanation and code examples.

Data Structures

When the importer successfully completed its job, the imported data is returned in an aiScene structure. This is the root point from where you can access all the various data types that a scene/model file can possibly contain. The Data Structures page describes how to interpret this data.

Extending the library

There are many 3d file formats in the world, and we're happy to support as many as possible. If you need support for a particular file format, why not implement it yourself and add it to the library? Writing importer plugins for assimp is considerably easy, as the whole postprocessing infrastructure is available and does much of the work for you. See the Extending the library page for more information.

Support & Feedback

If you have any questions/comments/suggestions/bug reports you're welcome to post them in our forums. Alternatively there's a mailing list, assimp-discussions.

Generated on Tue Jun 26 2012 21:41:08 for Assimp by doxygen 1.7.4


Assimp: Related Pages

  • Namespaces
  • Classes
  • Files
Related Pages
Here is a list of all related documentation pages:
  • Installation
  • Usage
  • Data Structures
  • Material System
  • Performance
  • Threading
  • Resources
  • Importer Notes
  • Extending the Library
  • Animation Overview
  • Deprecated List


Assimp: Installation

Installation

Using the pre-built libraries with Visual C++ 8/9

If you develop at Visual Studio 2005 or 2008, you can simply use the pre-built linker libraries provided in the distribution. Extract all files to a place of your choice. A directory called "assimp" will be created there. Add the assimp/include path to your include paths (Menu->Extras->Options->Projects and Solutions->VC++ Directories->Include files) and the assimp/lib/<Compiler> path to your linker paths (Menu->Extras->Options->Projects and Solutions->VC++ Directories->Library files). This is neccessary only once to setup all paths inside you IDE.

To use the library in your C++ project you have to include either <assimp/Importer.hpp> or <assimp/cimport.h> plus some others starting with <types.h>. If you set up your IDE correctly the compiler should be able to find the files. Then you have to add the linker library to your project dependencies. Link to <assimp_root>/lib/<config-name>/assimp.lib. config-name is one of the predefined project configs. For static linking, use release/debug. See the sections below on this page for more information on the other build configs. If done correctly you should now be able to compile, link, run and use the application. If the linker complains about some integral functions being defined twice you propably have mixed the runtimes. Recheck the project configuration (project properties -> C++ -> Code generation -> Runtime) if you use static runtimes (Multithreaded / Multithreaded Debug) or dynamic runtimes (Multithreaded DLL / Multithreaded Debug DLL). Choose the assimp linker lib accordingly.

Please don't forget to also read the Microsoft Compilers and the C++ Standard Library section on MSVC and the STL.

Microsoft Compilers and the C++ Standard Library

In VC8 and VC9 Microsoft introduced some Standard Library debugging features. A good example are improved iterator checks and various useful debug checks. The problem is the performance penalty that incurs with those extra checks.

Most of these security enhancements are active in release builds by default, rendering assimp several times slower. However, it is possible to disable them by setting

_HAS_ITERATOR_DEBUGGING=0
_SECURE_SCL=0

in the preprocessor options (or alternatively in the source code, just before the STL is included for the first time). assimp's vc8 and vc9 configs enable these flags by default.

If you're linking statically against assimp: Make sure your applications uses the same STl settings! If you do not, there are two binary incompatible STL versions mangled together and you'll crash. Alternatively you can disable the fast STL settings for assimp by removing the 'FastSTL' property sheet from the vc project file.

If you're using assimp in a DLL/SO: It's ok. There's no STL used in the binary DLL/SO interface, so it doesn't care whether your application uses the same STL settings or not.

Another option is to build against a different STL implementation, for example STlport. There's a special Building against STLport section that has a description how to achieve this.

Building the library from scratch

To build the library on your own you first have to get hold of the dependencies. Fortunately, special attention was paid to keep the list of dependencies short. Unfortunately, the only dependency is boost which can be a bit painful to set up for certain development environments. Boost is a widely used collection of classes and functions for various purposes. Chances are that it was already installed along with your compiler. If not, you have to install it for yourself. Read the "Getting Started" section of the Boost documentation for how to setup boost. VisualStudio users can use a comfortable installer from http://www.boost-consulting.com/products/free. Choose the appropriate version of boost for your runtime of choice.

If you don't want to use boost, you can build against our "Boost-Workaround". It consists of very small implementations of the various boost utility classes used. However, you'll loose functionality (e.g. threading) by doing this. So, if you can use boost, you should use boost. Otherwise, See the NoBoost-Section later on this page for the details of the workaround.

Once boost is working, you have to set up a project for the assimp library in your favorite IDE. If you use VC2005 or VC2008, you can simply load the solution or project files in the workspaces/ folder, otherwise you have to create a new package and add all the headers and source files from the include/ and code/ directories. Set the temporary output folder to obj/, for example, and redirect the output folder to bin/. Then build the library - it should compile and link fine.

The last step is to integrate the library into your project. This is basically the same task as described in the "Using the pre-built libraries" section above: add the include/ and bin/ directories to your IDE's paths so that the compiler can find the library files. Alternatively you can simply add the assimp project to your project's overall solution and build it inside your solution.

Building without boost.

The Boost-Workaround consists of dummy replacements for some boost utility templates. Currently there are replacements for

  • boost.scoped_ptr
  • boost.scoped_array
  • boost.format
  • boost.random
  • boost.common_factor
  • boost.foreach
  • boost.tuple
  • boost.make_shared

These implementations are very limited and are not intended for use outside assimp. A compiler with full support for partial template specializations is required. To enable the workaround, put the following in your compiler's list of predefined macros:

#define ASSIMP_BUILD_BOOST_WORKAROUND

If you're working with the provided solutions for Visual Studio use the -noboost build configs.

assimp_BUILD_BOOST_WORKAROUND implies assimp_BUILD_SINGLETHREADED.
See the assimp_st section for more details.

Windows DLL Build

assimp can be built as DLL. You just need to select a -dll config from the list of project configs and you're fine.

NOTE: Theoretically, assimp-dll can be used with multithreaded (non-dll) runtime libraries, as long as you don't utilize any non-public stuff from the code folder. However, if you happen to encounter *very* strange problems, try changing the runtime to Multithreaded (Debug) DLL.

Building against STLport

STLport is a free, fast and secure STL replacement that works with all major compilers and platforms. To get it, download the latest release from <stlport.org>. Usually you'll just need to run 'configure' + a makefile (see their README for more details). Don't miss to add <stlport_root>/stlport to your compiler's default include paths - prior to the directory where your compiler vendor's headers lie. Do the same for <stlport_root>/lib and recompile assimp. To ensure you're really building against STLport see aiGetCompileFlags().
In our testing, STLport builds tend to be a bit faster than builds against Microsoft's C++ Standard Library.


Assimp: Usage

Usage

Access by C++ class interface

The assimp library can be accessed by both a class or flat function interface. The C++ class interface is the preferred way of interaction: you create an instance of class Assimp::Importer, maybe adjust some settings of it and then call Assimp::Importer::ReadFile(). The class will read the files and process its data, handing back the imported data as a pointer to an aiScene to you. You can now extract the data you need from the file. The importer manages all the resources for itsself. If the importer is destroyed, all the data that was created/read by it will be destroyed, too. So the easiest way to use the Importer is to create an instance locally, use its results and then simply let it go out of scope.

C++ example:

#include <assimp/Importer.hpp>      // C++ importer interface
#include <assimp/scene.h>           // Output data structure
#include <assimp/postprocess.h>     // Post processing flags

bool DoTheImportThing( const std::string& pFile)
{
  // Create an instance of the Importer class
  Assimp::Importer importer;

  // And have it read the given file with some example postprocessing
  // Usually - if speed is not the most important aspect for you - you'll
  // propably to request more postprocessing than we do in this example.
  const aiScene* scene = importer.ReadFile( pFile,
        aiProcess_CalcTangentSpace       |
        aiProcess_Triangulate            |
        aiProcess_JoinIdenticalVertices  |
        aiProcess_SortByPType);

  // If the import failed, report it
  if( !scene)
  {
    DoTheErrorLogging( importer.GetErrorString());
    return false;
  }

  // Now we can access the file's contents.
  DoTheSceneProcessing( scene);

  // We're done. Everything will be cleaned up by the importer destructor
  return true;
}

What exactly is read from the files and how you interpret it is described at the Data Structures page. The post processing steps that the assimp library can apply to the imported data are listed at aiPostProcessSteps. See the pp Post proccessing page for more details.

Note that the aiScene data structure returned is declared 'const'. Yes, you can get rid of these 5 letters with a simple cast. Yes, you may do that. No, it's not recommended (and it's suicide in DLL builds if you try to use new or delete on any of the arrays in the scene).

Access by plain-c function interface

The plain function interface is just as simple, but requires you to manually call the clean-up after you're done with the imported data. To start the import process, call aiImportFile() with the filename in question and the desired postprocessing flags like above. If the call is successful, an aiScene pointer with the imported data is handed back to you. When you're done with the extraction of the data you're interested in, call aiReleaseImport() on the imported scene to clean up all resources associated with the import.

C example:

#include <assimp/cimport.h>        // Plain-C interface
#include <assimp/scene.h>          // Output data structure
#include <assimp/postprocess.h>    // Post processing flags

bool DoTheImportThing( const char* pFile)
{
  // Start the import on the given file with some example postprocessing
  // Usually - if speed is not the most important aspect for you - you'll t
  // probably to request more postprocessing than we do in this example.
  const aiScene* scene = aiImportFile( pFile,
    aiProcess_CalcTangentSpace       |
        aiProcess_Triangulate            |
        aiProcess_JoinIdenticalVertices  |
        aiProcess_SortByPType);

  // If the import failed, report it
  if( !scene)
  {
    DoTheErrorLogging( aiGetErrorString());
    return false;
  }

  // Now we can access the file's contents
  DoTheSceneProcessing( scene);

  // We're done. Release all resources associated with this import
  aiReleaseImport( scene);
  return true;
}

Using custom IO logic with the C++ class interface

The assimp library needs to access files internally. This of course applies to the file you want to read, but also to additional files in the same folder for certain file formats. By default, standard C/C++ IO logic is used to access these files. If your application works in a special environment where custom logic is needed to access the specified files, you have to supply custom implementations of IOStream and IOSystem. A shortened example might look like this:

#include <assimp/IOStream.hpp>
#include <assimp/IOSystem.hpp>

// My own implementation of IOStream
class MyIOStream : public Assimp::IOStream
{
  friend class MyIOSystem;

protected:
  // Constructor protected for private usage by MyIOSystem
  MyIOStream(void);

public:
  ~MyIOStream(void);
  size_t Read( void* pvBuffer, size_t pSize, size_t pCount) { ... }
  size_t Write( const void* pvBuffer, size_t pSize, size_t pCount) { ... }
  aiReturn Seek( size_t pOffset, aiOrigin pOrigin) { ... }
  size_t Tell() const { ... }
  size_t FileSize() const { ... }
  void Flush () { ... }
};

// Fisher Price - My First Filesystem
class MyIOSystem : public Assimp::IOSystem
{
  MyIOSystem() { ... }
  ~MyIOSystem() { ... }

  // Check whether a specific file exists
  bool Exists( const std::string& pFile) const {
    ..
  }

  // Get the path delimiter character we'd like to see
  char GetOsSeparator() const {
    return '/';
  }

  // ... and finally a method to open a custom stream
  IOStream* Open( const std::string& pFile, const std::string& pMode) {
        return new MyIOStream( ... );
  }

  void Close( IOStream* pFile) { delete pFile; }
};

Now that your IO system is implemented, supply an instance of it to the Importer object by calling Assimp::Importer::SetIOHandler().

void DoTheImportThing( const std::string& pFile)
{
  Assimp::Importer importer;
  // put my custom IO handling in place
  importer.SetIOHandler( new MyIOSystem());

  // the import process will now use this implementation to access any file
  importer.ReadFile( pFile, SomeFlag | SomeOtherFlag);
}

Using custom IO logic with the plain-c function interface

The C interface also provides a way to override the file system. Control is not as fine-grained as for C++ although surely enough for almost any purpose. The process is simple:

  • Include cfileio.h
  • Fill an aiFileIO structure with custom file system callbacks (they're self-explanatory as they work similar to the CRT's fXXX functions)
  • .. and pass it as parameter to aiImportFileEx

Logging

The assimp library provides an easy mechanism to log messages. For instance if you want to check the state of your import and you just want to see, after which preprocessing step the import-process was aborted you can take a look into the log. Per default the assimp-library provides a default log implementation, where you can log your user specific message by calling it as a singleton with the requested logging-type. To see how this works take a look to this:

using namespace Assimp;

// Create a logger instance
DefaultLogger::create("",Logger::VERBOSE);

// Now I am ready for logging my stuff
DefaultLogger::get()->info("this is my info-call");

// Kill it after the work is done
DefaultLogger::kill();

At first you have to create the default-logger-instance (create). Now you are ready to rock and can log a little bit around. After that you should kill it to release the singleton instance.

If you want to integrate the assimp-log into your own GUI it my be helpful to have a mechanism writing the logs into your own log windows. The logger interface provides this by implementing an interface called LogStream. You can attach and detach this log stream to the default-logger instance or any implementation derived from Logger. Just derivate your own logger from the abstract base class LogStream and overwrite the write-method:

// Example stream
class myStream :
        public LogStream
{
public:
        // Constructor
        myStream()
        {
                // empty
        }

        // Destructor
        ~myStream()
        {
                // empty
        }

        // Write womethink using your own functionality
        void write(const char* message)
        {
                ::printf("%s\n", message);
        }
};

// Select the kinds of messages you want to receive on this log stream
const unsigned int severity = Logger::DEBUGGING|Logger::INFO|Logger::ERR|Logger::WARN;

// Attaching it to the default logger
Assimp::DefaultLogger::get()->attachStream( new myStream(), severity );

The severity level controls the kind of message which will be written into the attached stream. If you just want to log errors and warnings set the warn and error severity flag for those severities. It is also possible to remove a self defined logstream from an error severity by detaching it with the severity flag set:

unsigned int severity = 0;
severity |= Logger::DEBUGGING;

// Detach debug messages from you self defined stream
Assimp::DefaultLogger::get()->attachStream( new myStream(), severity );

If you want to implement your own logger just derive from the abstract base class #Logger and overwrite the methods debug, info, warn and error.

If you want to see the debug-messages in a debug-configured build, the Logger-interface provides a logging-severity. You can set it calling the following method:

Assimp::DefaultLogger::get()->setLogSeverity( LogSeverity log_severity );

The normal logging severity supports just the basic stuff like, info, warnings and errors. In the verbose level very fine-grained debug messages will be logged, too. Note that this kind kind of logging might decrease import performance.


Assimp: Data Structures

Data Structures

The assimp library returns the imported data in a collection of structures.

aiScene forms the root of the data, from here you gain access to all the nodes, meshes, materials, animations or textures that were read from the imported file. The aiScene is returned from a successful call to assimp::Importer::ReadFile(), aiImportFile() or aiImportFileEx() - see the Usage page for further information on how to use the library.

By default, all 3D data is provided in a right-handed coordinate system such as OpenGL uses. In this coordinate system, +X points to the right, -Z points away from the viewer into the screen and +Y points upwards. Several modeling packages such as 3D Studio Max use this coordinate system as well (or a rotated variant of it). By contrast, some other environments use left-handed coordinate systems, a prominent example being DirectX. If you need the imported data to be in a left-handed coordinate system, supply the aiProcess_MakeLeftHanded flag to the ReadFile() function call.

The output face winding is counter clockwise. Use aiProcess_FlipWindingOrder to get CW data.

x2

            x1
        x0

Outputted polygons can be literally everything: they're probably concave, self-intersecting or non-planar, although our built-in triangulation (aiProcess_Triangulate postprocessing step) doesn't handle the two latter.

The output UV coordinate system has its origin in the lower-left corner:

0y|1y ---------- 1x|1y
 |                |
 |                |
 |                |
0x|0y ---------- 1x|0y

Use the aiProcess_FlipUVs flag to get UV coordinates with the upper-left corner als origin.

All matrices in the library are row-major. That means that the matrices are stored row by row in memory, which is similar to the OpenGL matrix layout. A typical 4x4 matrix including a translational part looks like this:

X1  Y1  Z1  T1
X2  Y2  Z2  T2
X3  Y3  Z3  T3
0   0   0   1

... with (X1, X2, X3) being the X base vector, (Y1, Y2, Y3) being the Y base vector, (Z1, Z2, Z3) being the Z base vector and (T1, T2, T3) being the translation part. If you want to use these matrices in DirectX functions, you have to transpose them.

11.24.09: We changed the orientation of our quaternions to the most common convention to avoid confusion. However, if you're a previous user of Assimp and you update the library to revisions beyond SVNREV 502, you have to adapt your animation loading code to match the new quaternion orientation.

The Node Hierarchy

Nodes are little named entities in the scene that have a place and orientation relative to their parents. Starting from the scene's root node all nodes can have 0 to x child nodes, thus forming a hierarchy. They form the base on which the scene is built on: a node can refer to 0..x meshes, can be referred to by a bone of a mesh or can be animated by a key sequence of an animation. DirectX calls them "frames", others call them "objects", we call them aiNode.

A node can potentially refer to single or multiple meshes. The meshes are not stored inside the node, but instead in an array of aiMesh inside the aiScene. A node only refers to them by their array index. This also means that multiple nodes can refer to the same mesh, which provides a simple form of instancing. A mesh referred to by this way lives in the node's local coordinate system. If you want the mesh's orientation in global space, you'd have to concatenate the transformations from the referring node and all of its parents.

Most of the file formats don't really support complex scenes, though, but a single model only. But there are more complex formats such as .3ds, .x or .collada scenes which may contain an arbitrary complex hierarchy of nodes and meshes. I for myself would suggest a recursive filter function such as the following pseudocode:

void CopyNodesWithMeshes( aiNode node, SceneObject targetParent, Matrix4x4 accTransform)
{
  SceneObject parent;
  Matrix4x4 transform;

  // if node has meshes, create a new scene object for it
  if( node.mNumMeshes > 0)
  {
    SceneObjekt newObject = new SceneObject;
    targetParent.addChild( newObject);
    // copy the meshes
    CopyMeshes( node, newObject);

    // the new object is the parent for all child nodes
    parent = newObject;
    transform.SetUnity();
  } else
  {
    // if no meshes, skip the node, but keep its transformation
    parent = targetParent;
    transform = node.mTransformation * accTransform;
  }

  // continue for all child nodes
  for( all node.mChildren)
    CopyNodesWithMeshes( node.mChildren[a], parent, transform);
}

This function copies a node into the scene graph if it has children. If yes, a new scene object is created for the import node and the node's meshes are copied over. If not, no object is created. Potential child objects will be added to the old targetParent, but there transformation will be correct in respect to the global space. This function also works great in filtering the bone nodes - nodes that form the bone hierarchy for another mesh/node, but don't have any mesh themselves.

Meshes

All meshes of an imported scene are stored in an array of aiMesh* inside the aiScene. Nodes refer to them by their index in the array and providing the coordinate system for them, too. One mesh uses only a single material everywhere - if parts of the model use a different material, this part is moved to a separate mesh at the same node. The mesh refers to its material in the same way as the node refers to its meshes: materials are stored in an array inside aiScene, the mesh stores only an index into this array.

An aiMesh is defined by a series of data channels. The presence of these data channels is defined by the contents of the imported file: by default there are only those data channels present in the mesh that were also found in the file. The only channels guarenteed to be always present are aiMesh::mVertices and aiMesh::mFaces. You can test for the presence of other data by testing the pointers against NULL or use the helper functions provided by aiMesh. You may also specify several post processing flags at Importer::ReadFile() to let assimp calculate or recalculate additional data channels for you.

At the moment, a single aiMesh may contain a set of triangles and polygons. A single vertex does always have a position. In addition it may have one normal, one tangent and bitangent, zero to AI_MAX_NUMBER_OF_TEXTURECOORDS (4 at the moment) texture coords and zero to AI_MAX_NUMBER_OF_COLOR_SETS (4) vertex colors. In addition a mesh may or may not have a set of bones described by an array of aiBone structures. How to interpret the bone information is described later on.

Materials

See the Material System Page.

Bones

A mesh may have a set of bones in the form of aiBone structures.. Bones are a means to deform a mesh according to the movement of a skeleton. Each bone has a name and a set of vertices on which it has influence. Its offset matrix declares the transformation needed to transform from mesh space to the local space of this bone.

Using the bones name you can find the corresponding node in the node hierarchy. This node in relation to the other bones' nodes defines the skeleton of the mesh. Unfortunately there might also be nodes which are not used by a bone in the mesh, but still affect the pose of the skeleton because they have child nodes which are bones. So when creating the skeleton hierarchy for a mesh I suggest the following method:

a) Create a map or a similar container to store which nodes are necessary for the skeleton. Pre-initialise it for all nodes with a "no".
b) For each bone in the mesh:
b1) Find the corresponding node in the scene's hierarchy by comparing their names.
b2) Mark this node as "yes" in the necessityMap.
b3) Mark all of its parents the same way until you 1) find the mesh's node or 2) the parent of the mesh's node.
c) Recursively iterate over the node hierarchy
c1) If the node is marked as necessary, copy it into the skeleton and check its children
c2) If the node is marked as not necessary, skip it and do not iterate over its children.

Reasons: you need all the parent nodes to keep the transformation chain intact. For most file formats and modelling packages the node hierarchy of the skeleton is either a child of the mesh node or a sibling of the mesh node but this is by no means a requirement so you shouldn't rely on it. The node closest to the root node is your skeleton root, from there you start copying the hierarchy. You can skip every branch without a node being a bone in the mesh - that's why the algorithm skips the whole branch if the node is marked as "not necessary".

You should now have a mesh in your engine with a skeleton that is a subset of the imported hierarchy.

Animations

An imported scene may contain zero to x aiAnimation entries. An animation in this context is a set of keyframe sequences where each sequence describes the orientation of a single node in the hierarchy over a limited time span. Animations of this kind are usually used to animate the skeleton of a skinned mesh, but there are other uses as well.

An aiAnimation has a duration. The duration as well as all time stamps are given in ticks. To get the correct timing, all time stamp thus have to be divided by aiAnimation::mTicksPerSecond. Beware, though, that certain combinations of file format and exporter don't always store this information in the exported file. In this case, mTicksPerSecond is set to 0 to indicate the lack of knowledge.

The aiAnimation consists of a series of aiNodeAnim's. Each bone animation affects a single node in the node hierarchy only, the name specifying which node is affected. For this node the structure stores three separate key sequences: a vector key sequence for the position, a quaternion key sequence for the rotation and another vector key sequence for the scaling. All 3d data is local to the coordinate space of the node's parent, that means in the same space as the node's transformation matrix. There might be cases where animation tracks refer to a non-existent node by their name, but this should not be the case in your every-day data.

To apply such an animation you need to identify the animation tracks that refer to actual bones in your mesh. Then for every track:
a) Find the keys that lay right before the current anim time.
b) Optional: interpolate between these and the following keys.
c) Combine the calculated position, rotation and scaling to a tranformation matrix
d) Set the affected node's transformation to the calculated matrix.

If you need hints on how to convert to or from quaternions, have a look at the Matrix&Quaternion FAQ. I suggest using logarithmic interpolation for the scaling keys if you happen to need them - usually you don't need them at all.

Textures

Normally textures used by assets are stored in separate files, however, there are file formats embedding their textures directly into the model file. Such textures are loaded into an aiTexture structure.
There are two cases:
1) The texture is NOT compressed. Its color data is directly stored in the aiTexture structure as an array of aiTexture::mWidth * aiTexture::mHeight aiTexel structures. Each aiTexel represents a pixel (or "texel") of the texture image. The color data is stored in an unsigned RGBA8888 format, which can be easily used for both Direct3D and OpenGL (swizzling the order of the color components might be necessary). RGBA8888 has been chosen because it is well-known, easy to use and natively supported by nearly all graphics APIs.
2) This applies if aiTexture::mHeight == 0 is fullfilled. Then, texture is stored in a "compressed" format such as DDS or PNG. The term "compressed" does not mean that the texture data must actually be compressed, however the texture was found in the model file as if it was stored in a separate file on the harddisk. Appropriate decoders (such as libjpeg, libpng, D3DX, DevIL) are required to load theses textures. aiTexture::mWidth specifies the size of the texture data in bytes, aiTexture::pcData is a pointer to the raw image data and aiTexture::achFormatHint is either zeroed or contains the most common file extension of the embedded texture's format. This value is only set if assimp is able to determine the file format.


Assimp: Material System

Material System

Overview

All materials are stored in an array of aiMaterial inside the aiScene.

Each aiMesh refers to one material by its index in the array. Due to the vastly diverging definitions and usages of material parameters there is no hard definition of a material structure. Instead a material is defined by a set of properties accessible by their names. Have a look at assimp/material.h to see what types of properties are defined. In this file there are also various functions defined to test for the presence of certain properties in a material and retrieve their values.

Textures

Textures are organized in stacks, each stack being evaluated independently. The final color value from a particular texture stack is used in the shading equation. For example, the computed color value of the diffuse texture stack (aiTextureType_DIFFUSE) is multipled with the amount of incoming diffuse light to obtain the final diffuse color of a pixel.

 Stack                               Resulting equation

------------------------
| Constant base color  |             color
------------------------
| Blend operation 0    |             +
------------------------
| Strength factor 0    |             0.25*
------------------------
| Texture 0            |             texture_0
------------------------
| Blend operation 1    |             *
------------------------
| Strength factor 1    |             1.0*
------------------------
| Texture 1            |             texture_1
------------------------
  ...                                ...

Constants

All material key constants start with 'AI_MATKEY' (it's an ugly macro for historical reasons, don't ask).

Name | Data Type | Default Value | Meaning | Notes
NAME | aiString | n/a | The name of the material, if available. | Ignored by aiProcess_RemoveRedundantMaterials. Materials are considered equal even if their names are different.
COLOR_DIFFUSE | aiColor3D | black (0,0,0) | Diffuse color of the material. This is typically scaled by the amount of incoming diffuse light (e.g. using gouraud shading) | ---
COLOR_SPECULAR | aiColor3D | black (0,0,0) | Specular color of the material. This is typically scaled by the amount of incoming specular light (e.g. using phong shading) | ---
COLOR_AMBIENT | aiColor3D | black (0,0,0) | Ambient color of the material. This is typically scaled by the amount of ambient light | ---
COLOR_EMISSIVE | aiColor3D | black (0,0,0) | Emissive color of the material. This is the amount of light emitted by the object. In real time applications it will usually not affect surrounding objects, but raytracing applications may wish to treat emissive objects as light sources. | ---
COLOR_TRANSPARENT | aiColor3D | black (0,0,0) | Defines the transparent color of the material, this is the color to be multiplied with the color of translucent light to construct the final 'destination color' for a particular position in the screen buffer. T | ---
WIREFRAME | int | false | Specifies whether wireframe rendering must be turned on for the material. 0 for false, !0 for true. | ---
TWOSIDED | int | false | Specifies whether meshes using this material must be rendered without backface culling. 0 for false, !0 for true. | Some importers set this property if they don't know whether the output face oder is right. As long as it is not set, you may safely enable backface culling.
SHADING_MODEL | int | gouraud | One of the aiShadingMode enumerated values. Defines the library shading model to use for (real time) rendering to approximate the original look of the material as closely as possible. | The presence of this key might indicate a more complex material. If absent, assume phong shading only if a specular exponent is given.
BLEND_FUNC | int | false | One of the aiBlendMode enumerated values. Defines how the final color value in the screen buffer is computed from the given color at that position and the newly computed color from the material. Simply said, alpha blending settings. | -
OPACITY | float | 1.0 | Defines the opacity of the material in a range between 0..1. | Use this value to decide whether you have to activate alpha blending for rendering. OPACITY != 1 usually also implies TWOSIDED=1 to avoid cull artifacts.
SHININESS | float | 0.f | Defines the shininess of a phong-shaded material. This is actually the exponent of the phong specular equation | SHININESS=0 is equivalent to SHADING_MODEL=aiShadingMode_Gouraud.
SHININESS_STRENGTH | float | 1.0 | Scales the specular color of the material. | This value is kept separate from the specular color by most modelers, and so do we.
REFRACTI | float | 1.0 | Defines the Index Of Refraction for the material. That's not supported by most file formats. | Might be of interest for raytracing.
TEXTURE(t,n) | aiString | n/a | Defines the path to the n'th texture on the stack 't', where 'n' is any value >= 0 and 't' is one of the aiTextureType enumerated values. | See the 'Textures' section above.
TEXBLEND(t,n) | float | n/a | Defines the strength the n'th texture on the stack 't'. All color components (rgb) are multipled with this factor *before* any further processing is done. | -
TEXOP(t,n) | int | n/a | One of the aiTextureOp enumerated values. Defines the arithmetic operation to be used to combine the n'th texture on the stack 't' with the n-1'th. TEXOP(t,0) refers to the blend operation between the base color for this stack (e.g. COLOR_DIFFUSE for the diffuse stack) and the first texture. | -
MAPPING(t,n) | int | n/a | Defines how the input mapping coordinates for sampling the n'th texture on the stack 't' are computed. Usually explicit UV coordinates are provided, but some model file formats might also be using basic shapes, such as spheres or cylinders, to project textures onto meshes. | See the 'Textures' section below. aiProcess_GenUVCoords can be used to let Assimp compute proper UV coordinates from projective mappings.
UVWSRC(t,n) | int | n/a | Defines the UV channel to be used as input mapping coordinates for sampling the n'th texture on the stack 't'. All meshes assigned to this material share the same UV channel setup | Presence of this key implies MAPPING(t,n) to be aiTextureMapping_UV. See How to map UV channels to textures (MATKEY_UVWSRC) for more details.
MAPPINGMODE_U(t,n) | int | n/a | Any of the aiTextureMapMode enumerated values. Defines the texture wrapping mode on the x axis for sampling the n'th texture on the stack 't'. 'Wrapping' occurs whenever UVs lie outside the 0..1 range. | -
MAPPINGMODE_V(t,n) | int | n/a | Wrap mode on the v axis. See MAPPINGMODE_U. | -
TEXMAP_AXIS(t,n) | aiVector3D | n/a | Defines the base axis to to compute the mapping coordinates for the n'th texture on the stack 't' from. This is not required for UV-mapped textures. For instance, if MAPPING(t,n) is aiTextureMapping_SPHERE, U and V would map to longitude and latitude of a sphere around the given axis. The axis is given in local mesh space. | -
TEXFLAGS(t,n) | int | n/a | Defines miscellaneous flag for the n'th texture on the stack 't'. This is a bitwise combination of the aiTextureFlags enumerated values. | -

C++-API

Retrieving a property from a material is done using various utility functions. For C++ it's simply calling aiMaterial::Get()

aiMaterial* mat = .....

// The generic way
if(AI_SUCCESS != mat->Get(<material-key>,<where-to-store>)) {
   // handle epic failure here
}

Simple, isn't it? To get the name of a material you would use

aiString name;
mat->Get(AI_MATKEY_NAME,name);

Or for the diffuse color ('color' won't be modified if the property is not set)

aiColor3D color (0.f,0.f,0.f);
mat->Get(AI_MATKEY_COLOR_DIFFUSE,color);

Note: Get() is actually a template with explicit specializations for aiColor3D, aiColor4D, aiString, float, int and some others. Make sure that the type of the second parameter matches the expected data type of the material property (no compile-time check yet!). Don't follow this advice if you wish to encounter very strange results.

C-API

For good old C it's slightly different. Take a look at the aiGetMaterialGet<data-type> functions.

aiMaterial* mat = .....

if(AI_SUCCESS != aiGetMaterialFloat(mat,<material-key>,<where-to-store>)) {
   // handle epic failure here
}

To get the name of a material you would use

aiString name;
aiGetMaterialString(mat,AI_MATKEY_NAME,&name);

Or for the diffuse color ('color' won't be modified if the property is not set)

aiColor3D color (0.f,0.f,0.f);
aiGetMaterialColor(mat,AI_MATKEY_COLOR_DIFFUSE,&color);

How to map UV channels to textures (MATKEY_UVWSRC)

The MATKEY_UVWSRC property is only present if the source format doesn't specify an explicit mapping from textures to UV channels. Many formats don't do this and assimp is not aware of a perfect rule either.

Your handling of UV channels needs to be flexible therefore. Our recommendation is to use logic like this to handle most cases properly:

have only one uv channel?
   assign channel 0 to all textures and break

for all textures
   have uvwsrc for this texture?
      assign channel specified in uvwsrc
   else
      assign channels in ascending order for all texture stacks,
        i.e. diffuse1 gets channel 1, opacity0 gets channel 0.

Pseudo Code Listing

For completeness, the following is a very rough pseudo-code sample showing how to evaluate Assimp materials in your shading pipeline. You'll probably want to limit your handling of all those material keys to a reasonable subset suitable for your purposes (for example most 3d engines won't support highly complex multi-layer materials, but many 3d modellers do).

Also note that this sample is targeted at a (shader-based) rendering pipeline for real time graphics.

// ---------------------------------------------------------------------------------------
// Evaluate multiple textures stacked on top of each other
float3 EvaluateStack(stack)
{
  // For the 'diffuse' stack stack.base_color would be COLOR_DIFFUSE
  // and TEXTURE(aiTextureType_DIFFUSE,n) the n'th texture.

  float3 base = stack.base_color;
  for (every texture in stack)
  {
    // assuming we have explicit & pretransformed UVs for this texture
    float3 color = SampleTexture(texture,uv);

    // scale by texture blend factor
    color *= texture.blend;

    if (texture.op == add)
      base += color;
    else if (texture.op == multiply)
      base *= color;
    else // other blend ops go here
  }
  return base;
}

// ---------------------------------------------------------------------------------------
// Compute the diffuse contribution for a pixel
float3 ComputeDiffuseContribution()
{
  if (shading == none)
     return float3(1,1,1);

  float3 intensity (0,0,0);
  for (all lights in range)
  {
    float fac = 1.f;
    if (shading == gouraud)
      fac =  lambert-term ..
    else // other shading modes go here

    // handling of different types of lights, such as point or spot lights
    // ...

    // and finally sum the contribution of this single light ...
    intensity += light.diffuse_color * fac;
  }
  // ... and combine the final incoming light with the diffuse color
  return EvaluateStack(diffuse) * intensity;
}

// ---------------------------------------------------------------------------------------
// Compute the specular contribution for a pixel
float3 ComputeSpecularContribution()
{
  if (shading == gouraud || specular_strength == 0 || specular_exponent == 0)
    return float3(0,0,0);

  float3 intensity (0,0,0);
  for (all lights in range)
  {
    float fac = 1.f;
    if (shading == phong)
      fac =  phong-term ..
    else // other specular shading modes go here

    // handling of different types of lights, such as point or spot lights
    // ...

    // and finally sum the specular contribution of this single light ...
    intensity += light.specular_color * fac;
  }
  // ... and combine the final specular light with the specular color
  return EvaluateStack(specular) * intensity * specular_strength;
}

// ---------------------------------------------------------------------------------------
// Compute the ambient contribution for a pixel
float3 ComputeAmbientContribution()
{
  if (shading == none)
     return float3(0,0,0);

  float3 intensity (0,0,0);
  for (all lights in range)
  {
    float fac = 1.f;

    // handling of different types of lights, such as point or spot lights
    // ...

    // and finally sum the ambient contribution of this single light ...
    intensity += light.ambient_color * fac;
  }
  // ... and combine the final ambient light with the ambient color
  return EvaluateStack(ambient) * intensity;
}

// ---------------------------------------------------------------------------------------
// Compute the final color value for a pixel
// @param prev Previous color at that position in the framebuffer
float4 PimpMyPixel (float4 prev)
{
  // .. handle displacement mapping per vertex
  // .. handle bump/normal mapping

  // Get all single light contribution terms
  float3 diff = ComputeDiffuseContribution();
  float3 spec = ComputeSpecularContribution();
  float3 ambi = ComputeAmbientContribution();

  // .. and compute the final color value for this pixel
  float3 color = diff + spec + ambi;
  float3 opac  = EvaluateStack(opacity);

  // note the *slightly* strange meaning of additive and multiplicative blending here ...
  // those names will most likely be changed in future versions
  if (blend_func == add)
       return prev+color*opac;
  else if (blend_func == multiply)
       return prev*(1.0-opac)+prev*opac;

   return color;
}


Assimp: Performance

Performance

Overview

This page discusses general performance issues related to assimp.

Profiling

assimp has built-in support for very basic profiling and time measurement. To turn it on, set the GLOB_MEASURE_TIME configuration switch to true (nonzero). Results are dumped to the log file, so you need to setup an appropriate logger implementation with at least one output stream first (see the Logging Page for the details.).

Note that these measurements are based on a single run of the importer and each of the post processing steps, so a single result set is far away from being significant in a statistic sense. While precision can be improved by running the test multiple times, the low accuracy of the timings may render the results useless for smaller files.

A sample report looks like this (some unrelated log messages omitted, entries grouped for clarity):

Debug, T5488: START `total`
Info,  T5488: Found a matching importer for this file format

Debug, T5488: START `import`
Info,  T5488: BlendModifier: Applied the `Subdivision` modifier to `OBMonkey`
Debug, T5488: END   `import`, dt= 3.516 s

Debug, T5488: START `preprocess`
Debug, T5488: END   `preprocess`, dt= 0.001 s
Info,  T5488: Entering post processing pipeline

Debug, T5488: START `postprocess`
Debug, T5488: RemoveRedundantMatsProcess begin
Debug, T5488: RemoveRedundantMatsProcess finished
Debug, T5488: END   `postprocess`, dt= 0.001 s

Debug, T5488: START `postprocess`
Debug, T5488: TriangulateProcess begin
Info,  T5488: TriangulateProcess finished. All polygons have been triangulated.
Debug, T5488: END   `postprocess`, dt= 3.415 s

Debug, T5488: START `postprocess`
Debug, T5488: SortByPTypeProcess begin
Info,  T5488: Points: 0, Lines: 0, Triangles: 1, Polygons: 0 (Meshes, X = removed)
Debug, T5488: SortByPTypeProcess finished

Debug, T5488: START `postprocess`
Debug, T5488: JoinVerticesProcess begin
Debug, T5488: Mesh 0 (unnamed) | Verts in: 503808 out: 126345 | ~74.922
Info,  T5488: JoinVerticesProcess finished | Verts in: 503808 out: 126345 | ~74.9
Debug, T5488: END   `postprocess`, dt= 2.052 s

Debug, T5488: START `postprocess`
Debug, T5488: FlipWindingOrderProcess begin
Debug, T5488: FlipWindingOrderProcess finished
Debug, T5488: END   `postprocess`, dt= 0.006 s

Debug, T5488: START `postprocess`
Debug, T5488: LimitBoneWeightsProcess begin
Debug, T5488: LimitBoneWeightsProcess end
Debug, T5488: END   `postprocess`, dt= 0.001 s

Debug, T5488: START `postprocess`
Debug, T5488: ImproveCacheLocalityProcess begin
Debug, T5488: Mesh 0 | ACMR in: 0.851622 out: 0.718139 | ~15.7
Info,  T5488: Cache relevant are 1 meshes (251904 faces). Average output ACMR is 0.718139
Debug, T5488: ImproveCacheLocalityProcess finished.
Debug, T5488: END   `postprocess`, dt= 1.903 s

Info,  T5488: Leaving post processing pipeline
Debug, T5488: END   `total`, dt= 11.269 s

In this particular example only one fourth of the total import time was spent on the actual importing, while the rest of the time got consumed by the aiProcess_Triangulate, aiProcess_JoinIdenticalVertices and aiProcess_ImproveCacheLocality postprocessing steps. A wise selection of postprocessing steps is therefore essential to getting good performance. Of course this depends on the individual requirements of your application, in many of the typical use cases of assimp performance won't matter (i.e. in an offline content pipeline).


Assimp: Threading

Threading

Overview

This page discusses both assimps scalability in threaded environments and the precautions to be taken in order to use it from multiple threads concurrently.

Thread-safety / using Assimp concurrently from several threads

The library can be accessed by multiple threads simultaneously, as long as the following prerequisites are fulfilled:

  • Users of the C++-API should ensure that they use a dedicated Assimp::Importer instance for each thread. Constructing instances of Assimp::Importer is expensive, so it might be a good idea to let every thread maintain its own thread-local instance (which can be used to load as many files as necessary).
  • The C-API is thread safe.
  • When supplying custom IO logic, one must make sure the underlying implementation is thread-safe.
  • Custom log streams or logger replacements have to be thread-safe, too.

Multiple concurrent imports may or may not be beneficial, however. For certain file formats in conjunction with little or no post processing IO times tend to be the performance bottleneck. Intense post processing together with 'slow' file formats like X or Collada might scale well with multiple concurrent imports.

Internal threading

Internal multi-threading is not currently implemented.


Assimp: Resources

Resources

This page lists some useful resources for assimp.

Note that, even though the core team has an eye on them, we cannot guarantee the accuracy of third-party information. If in doubt, it's best to ask either on the mailing list or on our forums on SF.net.

  • assimp comes with some sample applications, these can be found in the ./samples folder. Don't forget to read the README file.
  • http://www.drivenbynostalgia.com/files/AssimpOpenGLDemo.rar - OpenGl animation sample using the library's animation import facilities.
  • http://nolimitsdesigns.com/game-design/open-asset-import-library-animation-loader/ is another utility to simplify animation playback.
  • http://ogldev.atspace.co.uk/www/tutorial22/tutorial22.html - Tutorial "Loading models using the Open Asset Import Library", out of a series of OpenGl tutorials.


Assimp: Importer Notes

Importer Notes

Blender

This section contains implementation notes for the Blender3D importer.

Overview

assimp provides a self-contained reimplementation of Blender's so called SDNA system (http://www.blender.org/development/architecture/notes-on-sdna/). SDNA allows Blender to be fully backward and forward compatible and to exchange files across all platforms. The BLEND format is thus a non-trivial binary monster and the loader tries to read the most of it, naturally limited by the scope of the aiScene output data structure. Consequently, if Blender is the only modeling tool in your asset work flow, consider writing a custom exporter from Blender if assimps format coverage does not meet the requirements.

Current status

The Blender loader does not support animations yet, but is apart from that considered relatively stable.

Notes

When filing bugs on the Blender loader, always give the Blender version (or, even better, post the file caused the error).

IFC

This section contains implementation notes on the IFC-STEP importer.

Overview

The library provides a partial implementation of the IFC2x3 industry standard for automatized exchange of CAE/architectural data sets. See http://en.wikipedia.org/wiki/Industry_Foundation_Classes for more information on the format. We aim at getting as much 3D data out of the files as possible.

Current status

IFC support is new and considered experimental. Please report any bugs you may encounter.

Notes

  • Only the STEP-based encoding is supported. IFCZIP and IFCXML are not (but IFCZIP can simply be unzipped to get a STEP file).
  • The importer leaves vertex coordinates untouched, but applies a global scaling to the root transform to convert from whichever unit the IFC file uses to metres.
  • If multiple geometric representations are provided, the choice which one to load is based on how expensive a representation seems to be in terms of import time. The loader also avoids representation types for which it has known deficits.
  • Not supported are arbitrary binary operations (binary clipping is implemented, though).
  • Of the various relationship types that IFC knows, only aggregation, containment and material assignment are resolved and mapped to the output graph.
  • The implementation knows only about IFC2X3 and applies this rule set to all models it encounters, regardless of their actual version. Loading of older or newer files may fail with parsing errors.

Ogre

ATTENTION*: The Ogre-Loader is currently under development, many things have changed after this documentation was written, but they are not final enough to rewrite the documentation. So things may have changed by now!

This section contains implementations notes for the OgreXML importer.

Overview

Ogre importer is currently optimized for the Blender Ogre exporter, because thats the only one that I use. You can find the Blender Ogre exporter at: http://www.ogre3d.org/forums/viewtopic.php?f=8&t=45922

What will be loaded?

Mesh: Faces, Positions, Normals and all TexCoords. The Materialname will be used to load the material.

Material: The right material in the file will be searched, the importer should work with materials who have 1 technique and 1 pass in this technique. From there, the texturename (for 1 color- and 1 normalmap) and the materialcolors (but not in custom materials) will be loaded. Also, the materialname will be set.

Skeleton: Skeleton with Bone hierarchy (Position and Rotation, but no Scaling in the skeleton is supported), names and transformations, animations with rotation, translation and scaling keys.

How to export Files from Blender

You can find informations about how to use the Ogreexporter by your own, so here are just some options that you need, so the assimp importer will load everything correctly:

  • Use either "Rendering Material" or "Custom Material" see Materials
  • do not use "Flip Up Axies to Y"
  • use "Skeleton name follow mesh"

XML Format

There is a binary and a XML mesh Format from Ogre. This loader can only Handle xml files, but don't panic, there is a command line converter, which you can use to create XML files from Binary Files. Just look on the Ogre page for it.

Currently you can only load meshes. So you will need to import the *.mesh.xml file, the loader will try to find the appendant material and skeleton file.

The skeleton file must have the same name as the mesh file, e.g. fish.mesh.xml and fish.skeleton.xml.

Materials

The material file can have the same name as the mesh file (if the file is model.mesh or model.mesh.xml the loader will try to load model.material), or you can use Importer::Importer::SetPropertyString(AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE, "materiafile.material") to specify the name of the material file. This is especially usefull if multiply materials a stored in a single file. The importer will first try to load the material with the same name as the mesh and only if this can't be open try to load the alternate material file. The default material filename is "Scene.material".

We suggest that you use custom materials, because they support multiple textures (like colormap and normalmap). First of all you should read the custom material sektion in the Ogre Blender exporter Help File, and than use the assimp.tlp template, which you can find in scripts/OgreImpoter/Assimp.tlp in the assimp source. If you don't set all values, don't worry, they will be ignored during import.

If you want more properties in custom materials, you can easily expand the ogre material loader, it will be just a few lines for each property. Just look in OgreImporterMaterial.cpp

Properties

  • IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME: Normally, a texture is loaded as a colormap, if no target is specified in the materialfile. Is this switch is enabled, texture names ending with _n, _l, _s are used as normalmaps, lightmaps or specularmaps.
    Property type: Bool. Default value: false.
  • IMPORT_OGRE_MATERIAL_FILE: Ogre Meshes contain only the MaterialName, not the MaterialFile. If there is no material file with the same name as the material, Ogre Importer will try to load this file and search the material in it.
    Property type: String. Default value: guessed.

Todo

  • Load colors in custom materials
  • extend custom and normal material loading
  • fix bone hierarchy bug
  • test everything elaboratly
  • check for non existent animation keys (what happens if a one time not all bones have a key?)


Assimp: Extending the Library

Extending the Library

Overview

Or - how to write your own loaders. It's easy. You just need to implement the Assimp::BaseImporter class, which defines a few abstract methods, register your loader, test it carefully and provide test models for it.

OK, that sounds too easy :-). The whole procedure for a new loader merely looks like this:

  • Create a header (FormatNameImporter.h) and a unit (FormatNameImporter.cpp) in the <root>/code/ directory
  • Add them to the following workspaces: vc8 and vc9 (the files are in the workspaces directory), CMAKE (code/CMakeLists.txt, create a new source group for your importer and put them also to ADD_LIBRARY( assimp SHARED))
  • Include AssimpPCH.h - this is the PCH file, and it includes already most Assimp-internal stuff.

  • Open Importer.cpp and include your header just below the (include_new_importers_here) line, guarded by a #define

    #if (!defined assimp_BUILD_NO_FormatName_IMPORTER)
        ...
#endif

    Wrap the same guard around your .cpp!

  • Now advance to the (register_new_importers_here) line in the Importer.cpp and register your importer there - just like all the others do.
  • Setup a suitable test environment (i.e. use AssimpView or your own application), make sure to enable the aiProcess_ValidateDataStructure flag and enable verbose logging. That is, simply call before you import anything:
    DefaultLogger::create("AssimpLog.txt",Logger::VERBOSE)
  • Implement the Assimp::BaseImporter::CanRead(), Assimp::BaseImporter::InternReadFile() and Assimp::BaseImporter::GetExtensionList(). Just copy'n'paste the template from Appendix A and adapt it for your needs.
  • For error handling, throw a dynamic allocated ImportErrorException (see Appendix A) for critical errors, and log errors, warnings, infos and debuginfos with DefaultLogger::get()->[error, warn, debug, info].
  • Make sure that your loader compiles against all build configurations on all supported platforms. This includes -noboost! To avoid problems, see the boost section on this page for a list of all 'allowed' boost classes (again, this grew historically when we had to accept that boost is not THAT widely spread that one could rely on it being available everywhere).
  • Provide some _free_ test models in <root>/test/models/<FormatName>/ and credit their authors. Test files for a file format shouldn't be too large (~500 KiB in total), and not too repetive. Try to cover all format features with test data.
  • Done! Please, share your loader that everyone can profit from it!

Properties

You can use properties to chance the behavior of you importer. In order to do so, you have to overide BaseImporter::SetupProperties, and specify you custom properties in config.h. Just have a look to the other AI_CONFIG_IMPORT_* defines and you will understand, how it works.

The properties can be set with Importer::SetProperty***() and can be accessed in your SetupProperties function with Importer::GetProperty***(). You can store the properties as a member variable of your importer, they are thread safe.

Notes for text importers

  • Try to make your parser as flexible as possible. Don't rely on particular layout, whitespace/tab style, except if the file format has a strict definition, in which case you should always warn about spec violations. But the general rule of thumb is be strict in what you write and tolerant in what you accept.
  • Call Assimp::BaseImporter::ConvertToUTF8() before you parse anything to convert foreign encodings to UTF-8. That's not necessary for XML importers, which must use the provided IrrXML for reading.

Notes for binary importers

  • Take care of endianess issues! Assimp importers mostly support big-endian platforms, which define the AI_BUILD_BIG_ENDIAN constant. See the next section for a list of utilities to simplify this task.
  • Don't trust the input data! Check all offsets!

Utilities

Mixed stuff for internal use by loaders, mostly documented (most of them are already included by AssimpPCH.h):

  • ByteSwap (ByteSwap.h) - manual byte swapping stuff for binary loaders.
  • StreamReader (StreamReader.h) - safe, endianess-correct, binary reading.
  • IrrXML (irrXMLWrapper.h) - for XML-parsing (SAX.
  • CommentRemover (RemoveComments.h) - remove single-line and multi-line comments from a text file.
  • fast_atof, strtoul10, strtoul16, SkipSpaceAndLineEnd, SkipToNextToken .. large family of low-level parsing functions, mostly declared in fast_atof.h, StringComparison.h and ParsingUtils.h (a collection that grew historically, so don't expect perfect organization).
  • ComputeNormalsWithSmoothingsGroups() (SmoothingGroups.h) - Computes normal vectors from plain old smoothing groups.
  • SkeletonMeshBuilder (SkeletonMeshBuilder.h) - generate a dummy mesh from a given (animation) skeleton.
  • StandardShapes (StandardShapes.h) - generate meshes for standard solids, such as platonic primitives, cylinders or spheres.
  • BatchLoader (BaseImporter.h) - manage imports from external files. Useful for file formats which spread their data across multiple files.
  • SceneCombiner (SceneCombiner.h) - exhaustive toolset to merge multiple scenes. Useful for file formats which spread their data across multiple files.

Filling materials

The required definitions zo set/remove/query keys in aiMaterial structures are declared in MaterialSystem.h, in a aiMaterial derivate called aiMaterial. The header is included by AssimpPCH.h, so you don't need to bother.

aiMaterial* mat = new aiMaterial();

const float spec = 16.f;
mat->AddProperty(&spec, 1, AI_MATKEY_SHININESS);

//set the name of the material:
NewMaterial->AddProperty(&aiString(MaterialName.c_str()), AI_MATKEY_NAME);//MaterialName is a std::string

//set the first diffuse texture
NewMaterial->AddProperty(&aiString(Texturename.c_str()), AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));//again, Texturename is a std::string

Boost

The boost whitelist:

  • boost.scoped_ptr
  • boost.scoped_array
  • boost.format
  • boost.random
  • boost.common_factor
  • boost.foreach
  • boost.tuple

(if you happen to need something else, i.e. boost::thread, make this an optional feature. assimp_BUILD_BOOST_WORKAROUND is defined for -noboost builds)

Appendix A - Template for BaseImporter's abstract methods

// -------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool xxxxImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler,
        bool checkSig) const
{
        const std::string extension = GetExtension(pFile);
        if(extension == "xxxx") {
                return true;
        }
        if (!extension.length() || checkSig) {
                // no extension given, or we're called a second time because no
                // suitable loader was found yet. This means, we're trying to open
                // the file and look for and hints to identify the file format.
                // #Assimp::BaseImporter provides some utilities:
                //
                // #Assimp::BaseImporter::SearchFileHeaderForToken - for text files.
                // It reads the first lines of the file and does a substring check
                // against a given list of 'magic' strings.
                //
                // #Assimp::BaseImporter::CheckMagicToken - for binary files. It goes
                // to a particular offset in the file and and compares the next words
                // against a given list of 'magic' tokens.

                // These checks MUST be done (even if !checkSig) if the file extension
                // is not exclusive to your format. For example, .xml is very common
                // and (co)used by many formats.
        }
        return false;
}

// -------------------------------------------------------------------------------
// Get list of file extensions handled by this loader
void xxxxImporter::GetExtensionList(std::set<std::string>& extensions)
{
        extensions.insert("xxx");
}

// -------------------------------------------------------------------------------
void xxxxImporter::InternReadFile( const std::string& pFile,
        aiScene* pScene, IOSystem* pIOHandler)
{
        boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));

        // Check whether we can read from the file
        if( file.get() == NULL) {
                throw DeadlyImportError( "Failed to open xxxx file " + pFile + ".");
        }

        // Your task: fill pScene
        // Throw a ImportErrorException with a meaningful (!) error message if
        // something goes wrong.
}


Assimp: Animation Overview

Animation Overview

Transformations

This diagram shows how you can calculate your transformationmatrices for an animated character:


Assimp: Deprecated List

Deprecated List

Member aiProcess_ConvertToLeftHanded


Assimp: Class List

  • Class List
  • Class Index
  • Class Hierarchy
  • Class Members
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
aiAnimation | An animation consists of keyframe data for a number of nodes
aiAnimMesh | NOT CURRENTLY IN USE
aiBone | A single bone of a mesh
aiCamera | Helper structure to describe a virtual camera
aiColor3D | Represents a color in Red-Green-Blue space
aiColor4t< TReal > | Represents a color in Red-Green-Blue space including an alpha component
aiExportDataBlob | Describes a blob of exported scene data
aiExportFormatDesc | Describes an file format which Assimp can export to
aiFace | A single face in a mesh, referring to multiple vertices
aiFile | C-API: File callbacks
aiFileIO | C-API: File system callbacks
aiImporterDesc | Meta information about a particular importer
aiLight | Helper structure to describe a light source
aiLogStream | C-API: Represents a log stream
aiMaterial | Data structure for a material
aiMatrix3x3t< TReal > | Represents a row-major 3x3 matrix
aiMatrix4x4t< TReal > | Represents a row-major 4x4 matrix, use this for homogeneous coordinates
aiMesh | A mesh represents a geometry or model with a single material
aiMeshAnim | Describes vertex-based animations for a single mesh or a group of meshes
aiMeshKey | Binds a anim mesh to a specific point in time
aiNode | A node in the imported hierarchy
aiNodeAnim | Describes the animation of a single node
aiPlane | Represents a plane in a three-dimensional, euclidean space
aiPropertyStore | C-API: Represents an opaque set of settings to be used during importing
aiQuaterniont< TReal > | Represents a quaternion in a 4D vector
aiQuatKey | A time-value pair specifying a rotation for the given time
aiRay | Represents a ray
aiScene | The root structure of the imported data
aiString | Represents an UTF-8 string, zero byte terminated
aiTexel | Helper structure to represent a texel in a ARGB8888 format
aiTexture | Helper structure to describe an embedded texture
aiUVTransform | Defines how an UV channel is transformed
aiVector2t< TReal > | Represents a two-dimensional vector
aiVector3t< TReal > | Represents a three-dimensional vector
aiVectorKey | A time-value pair specifying a certain 3D vector for the given time
aiVertexWeight | A single influence of a bone on a vertex
Assimp::BaseImporter | FOR IMPORTER PLUGINS ONLY: The BaseImporter defines a common interface for all importer worker classes
Assimp::DefaultLogger | CPP-API: Primary logging facility of Assimp
Assimp::Exporter | CPP-API: The Exporter class forms an C++ interface to the export functionality of the Open Asset Import Library
Assimp::Exporter::ExportFormatEntry | Internal description of an Assimp export format option
Assimp::Importer | CPP-API: The Importer class forms an C++ interface to the functionality of the Open Asset Import Library
Assimp::Interpolator< T > | CPP-API: Utility class to simplify interpolations of various data types
Assimp::IOStream | CPP-API: Class to handle file I/O for C++
Assimp::IOSystem | CPP-API: Interface to the file system
Assimp::Logger | CPP-API: Abstract interface for logger implementations
Assimp::LogStream | CPP-API: Abstract interface for log stream implementations
Assimp::NullLogger | CPP-API: Empty logging implementation
Assimp::ProgressHandler | CPP-API: Abstract interface for custom progress report receivers
Assimp::ScopeGuard< T > |


Assimp: aiAnimation Struct Reference

  • Class Members
Public Member Functions | Public Attributes
aiAnimation Struct Reference

An animation consists of keyframe data for a number of nodes. More...

List of all members.

Public Member Functions

aiAnimation ()
~aiAnimation ()

Public Attributes

aiNodeAnim ** mChannels
The node animation channels.
double | mDuration
Duration of the animation in ticks.
aiMeshAnim ** mMeshChannels
The mesh animation channels.
aiString mName
The name of the animation.
unsigned int | mNumChannels
The number of bone animation channels.
unsigned int | mNumMeshChannels
The number of mesh animation channels.
double | mTicksPerSecond
Ticks per second.

Detailed Description

An animation consists of keyframe data for a number of nodes.

For each node affected by the animation a separate series of data is given.

Constructor & Destructor Documentation

aiAnimation::aiAnimation ( ) [inline]
aiAnimation::~aiAnimation ( ) [inline]

Member Data Documentation

aiNodeAnim** aiAnimation::mChannels

The node animation channels.

Each channel affects a single node. The array is mNumChannels in size.

double aiAnimation::mDuration

Duration of the animation in ticks.

aiMeshAnim** aiAnimation::mMeshChannels

The mesh animation channels.

Each channel affects a single mesh. The array is mNumMeshChannels in size.

aiString aiAnimation::mName

The name of the animation.

If the modeling package this data was exported from does support only a single animation channel, this name is usually empty (length is zero).

unsigned int aiAnimation::mNumChannels

The number of bone animation channels.

Each channel affects a single node.

unsigned int aiAnimation::mNumMeshChannels

The number of mesh animation channels.

Each channel affects a single mesh and defines vertex-based animation.

double aiAnimation::mTicksPerSecond

Ticks per second.

0 if not specified in the imported file

The documentation for this struct was generated from the following file:
  • anim.h


Assimp: aiAnimMesh Struct Reference

Public Member Functions | Public Attributes
aiAnimMesh Struct Reference

NOT CURRENTLY IN USE. More...

List of all members.

Public Member Functions

aiAnimMesh ()
bool | HasNormals () const
Check whether the anim mesh overrides the vertex normals of its host mesh.
bool | HasPositions () const
Check whether the anim mesh overrides the vertex positions of its host mesh.
bool | HasTangentsAndBitangents () const
Check whether the anim mesh overrides the vertex tangents and bitangents of its host mesh.
bool | HasTextureCoords (unsigned int pIndex) const
Check whether the anim mesh overrides a particular set of texture coordinates on his host mesh.
bool | HasVertexColors (unsigned int pIndex) const
Check whether the anim mesh overrides a particular set of vertex colors on his host mesh.
~aiAnimMesh ()

Public Attributes

aiVector3D * mBitangents
Replacement for aiMesh::mBitangents.
aiColor4D * | mColors [AI_MAX_NUMBER_OF_COLOR_SETS]
Replacement for aiMesh::mColors.
aiVector3D * mNormals
Replacement for aiMesh::mNormals.
unsigned int | mNumVertices
The number of vertices in the aiAnimMesh, and thus the length of all the member arrays.
aiVector3D * mTangents
Replacement for aiMesh::mTangents.
aiVector3D * | mTextureCoords [AI_MAX_NUMBER_OF_TEXTURECOORDS]
Replacement for aiMesh::mTextureCoords.
aiVector3D * mVertices
Replacement for aiMesh::mVertices.

Detailed Description

NOT CURRENTLY IN USE.

An AnimMesh is an attachment to an aiMesh stores per-vertex animations for a particular frame.

You may think of an aiAnimMesh as a `patch` for the host mesh, which replaces only certain vertex data streams at a particular time. Each mesh stores n attached attached meshes (aiMesh::mAnimMeshes). The actual relationship between the time line and anim meshes is established by aiMeshAnim, which references singular mesh attachments by their ID and binds them to a time offset.

Constructor & Destructor Documentation

aiAnimMesh::aiAnimMesh ( ) [inline]
aiAnimMesh::~aiAnimMesh ( ) [inline]

Member Function Documentation

bool aiAnimMesh::HasNormals ( ) const [inline]

Check whether the anim mesh overrides the vertex normals of its host mesh.

bool aiAnimMesh::HasPositions ( ) const [inline]

Check whether the anim mesh overrides the vertex positions of its host mesh.

bool aiAnimMesh::HasTangentsAndBitangents ( ) const [inline]

Check whether the anim mesh overrides the vertex tangents and bitangents of its host mesh.

As for aiMesh, tangents and bitangents always go together.

bool aiAnimMesh::HasTextureCoords ( unsigned int pIndex ) const [inline]

Check whether the anim mesh overrides a particular set of texture coordinates on his host mesh.

Parameters:
pIndex 0<index<AI_MAX_NUMBER_OF_TEXTURECOORDS
bool aiAnimMesh::HasVertexColors ( unsigned int pIndex ) const [inline]

Check whether the anim mesh overrides a particular set of vertex colors on his host mesh.

Parameters:
pIndex 0<index<AI_MAX_NUMBER_OF_COLOR_SETS

Member Data Documentation

aiVector3D* aiAnimMesh::mBitangents

Replacement for aiMesh::mBitangents.

aiColor4D* aiAnimMesh::mColors[AI_MAX_NUMBER_OF_COLOR_SETS]

Replacement for aiMesh::mColors.

aiVector3D* aiAnimMesh::mNormals

Replacement for aiMesh::mNormals.

unsigned int aiAnimMesh::mNumVertices

The number of vertices in the aiAnimMesh, and thus the length of all the member arrays.

This has always the same value as the mNumVertices property in the corresponding aiMesh. It is duplicated here merely to make the length of the member arrays accessible even if the aiMesh is not known, e.g. from language bindings.

aiVector3D* aiAnimMesh::mTangents

Replacement for aiMesh::mTangents.

aiVector3D* aiAnimMesh::mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS]

Replacement for aiMesh::mTextureCoords.

aiVector3D* aiAnimMesh::mVertices

Replacement for aiMesh::mVertices.

If this array is non-NULL, it *must* contain mNumVertices entries. The corresponding array in the host mesh must be non-NULL as well - animation meshes may neither add or nor remove vertex components (if a replacement array is NULL and the corresponding source array is not, the source data is taken instead)

The documentation for this struct was generated from the following file:
  • mesh.h


Assimp: aiBone Struct Reference

Public Member Functions | Public Attributes
aiBone Struct Reference

A single bone of a mesh. More...

List of all members.

Public Member Functions

aiBone ()
Default constructor.
aiBone (const aiBone &other)
Copy constructor.
~aiBone ()
Destructor - deletes the array of vertex weights.

Public Attributes

aiString mName
The name of the bone.
unsigned int mNumWeights
The number of vertices affected by this bone The maximum value for this member is AI_MAX_BONE_WEIGHTS.
aiMatrix4x4 mOffsetMatrix
Matrix that transforms from mesh space to bone space in bind pose.
aiVertexWeight * mWeights
The vertices affected by this bone.

Detailed Description

A single bone of a mesh.

A bone has a name by which it can be found in the frame hierarchy and by which it can be addressed by animations. In addition it has a number of influences on vertices.

Constructor & Destructor Documentation

aiBone::aiBone ( ) [inline]

Default constructor.

aiBone::aiBone ( const aiBone & other ) [inline]

Copy constructor.

aiBone::~aiBone ( ) [inline]

Destructor - deletes the array of vertex weights.

Member Data Documentation

aiString aiBone::mName

The name of the bone.

unsigned int aiBone::mNumWeights

The number of vertices affected by this bone The maximum value for this member is AI_MAX_BONE_WEIGHTS.

aiMatrix4x4 aiBone::mOffsetMatrix

Matrix that transforms from mesh space to bone space in bind pose.

aiVertexWeight* aiBone::mWeights

The vertices affected by this bone.

The documentation for this struct was generated from the following file:
  • mesh.h


Assimp: aiCamera Struct Reference

Public Member Functions | Public Attributes
aiCamera Struct Reference

Helper structure to describe a virtual camera. More...

List of all members.

Public Member Functions

aiCamera ()
void | GetCameraMatrix (aiMatrix4x4 &out) const
Get a *right-handed* camera matrix from me.

Public Attributes

float | mAspect
Screen aspect ratio.
float | mClipPlaneFar
Distance of the far clipping plane from the camera.
float | mClipPlaneNear
Distance of the near clipping plane from the camera.
float | mHorizontalFOV
Half horizontal field of view angle, in radians.
aiVector3D mLookAt
'LookAt' - vector of the camera coordinate system relative to the coordinate space defined by the corresponding node.
aiString mName
The name of the camera.
aiVector3D mPosition
Position of the camera relative to the coordinate space defined by the corresponding node.
aiVector3D mUp
'Up' - vector of the camera coordinate system relative to the coordinate space defined by the corresponding node.

Detailed Description

Helper structure to describe a virtual camera.

Cameras have a representation in the node graph and can be animated. An important aspect is that the camera itself is also part of the scenegraph. This means, any values such as the look-at vector are not *absolute*, they're relative to the coordinate system defined by the node which corresponds to the camera. This allows for camera animations. For static cameras parameters like the 'look-at' or 'up' vectors are usually specified directly in aiCamera, but beware, they could also be encoded in the node transformation. The following (pseudo)code sample shows how to do it:

 // Get the camera matrix for a camera at a specific time
 // if the node hierarchy for the camera does not contain
 // at least one animated node this is a static computation
 get-camera-matrix (node sceneRoot, camera cam) : matrix
 {
    node   cnd = find-node-for-camera(cam)
    matrix cmt = identity()

    // as usual - get the absolute camera transformation for this frame
    for each node nd in hierarchy from sceneRoot to cnd
      matrix cur
      if (is-animated(nd))
         cur = eval-animation(nd)
      else cur = nd->mTransformation;
      cmt = mult-matrices( cmt, cur )
    end for

    // now multiply with the camera's own local transform
    cam = mult-matrices (cam, get-camera-matrix(cmt) )
 }
Note:
some file formats (such as 3DS, ASE) export a "target point" - the point the camera is looking at (it can even be animated). Assimp writes the target point as a subnode of the camera's main node, called "<camName>.Target". However this is just additional information then the transformation tracks of the camera main node make the camera already look in the right direction.

Constructor & Destructor Documentation

aiCamera::aiCamera ( ) [inline]

Member Function Documentation

void aiCamera::GetCameraMatrix ( aiMatrix4x4 & out ) const [inline]

Get a *right-handed* camera matrix from me.

Parameters:
out Camera matrix to be filled

todo: test ... should work, but i'm not absolutely sure

We don't know whether these vectors are already normalized ...

Member Data Documentation

float aiCamera::mAspect

Screen aspect ratio.

This is the ration between the width and the height of the screen. Typical values are 4/3, 1/2 or 1/1. This value is 0 if the aspect ratio is not defined in the source file. 0 is also the default value.

float aiCamera::mClipPlaneFar

Distance of the far clipping plane from the camera.

The far clipping plane must, of course, be further away than the near clipping plane. The default value is 1000.f. The ratio between the near and the far plane should not be too large (between 1000-10000 should be ok) to avoid floating-point inaccuracies which could lead to z-fighting.

float aiCamera::mClipPlaneNear

Distance of the near clipping plane from the camera.

The value may not be 0.f (for arithmetic reasons to prevent a division through zero). The default value is 0.1f.

float aiCamera::mHorizontalFOV

Half horizontal field of view angle, in radians.

The field of view angle is the angle between the center line of the screen and the left or right border. The default value is 1/4PI.

aiVector3D aiCamera::mLookAt

'LookAt' - vector of the camera coordinate system relative to the coordinate space defined by the corresponding node.

This is the viewing direction of the user. The default value is 0|0|1. The vector may be normalized, but it needn't.

aiString aiCamera::mName

The name of the camera.

There must be a node in the scenegraph with the same name. This node specifies the position of the camera in the scene hierarchy and can be animated.

aiVector3D aiCamera::mPosition

Position of the camera relative to the coordinate space defined by the corresponding node.

The default value is 0|0|0.

aiVector3D aiCamera::mUp

'Up' - vector of the camera coordinate system relative to the coordinate space defined by the corresponding node.

The 'right' vector of the camera coordinate system is the cross product of the up and lookAt vectors. The default value is 0|1|0. The vector may be normalized, but it needn't.

The documentation for this struct was generated from the following file:
  • camera.h


Assimp: aiColor3D Struct Reference

Public Member Functions | Public Attributes
aiColor3D Struct Reference

Represents a color in Red-Green-Blue space. More...

List of all members.

Public Member Functions

aiColor3D ()
aiColor3D (float _r, float _g, float _b)
aiColor3D (const aiColor3D &o)
aiColor3D (float _r)
bool | IsBlack () const
Check whether a color is black.
bool | operator!= (const aiColor3D &other) const
Component-wise inverse comparison.
aiColor3D | operator* (const aiColor3D &c) const
Component-wise multiplication.
aiColor3D | operator* (float f) const
Multiply with a scalar.
aiColor3D | operator+ (const aiColor3D &c) const
Component-wise addition.
aiColor3D | operator- (const aiColor3D &c) const
Component-wise subtraction.
bool | operator== (const aiColor3D &other) const
Component-wise comparison.
float | operator[] (unsigned int i) const
Access a specific color component.
float & | operator[] (unsigned int i)
Access a specific color component.

Public Attributes

float | b
float | g
float | r
Red, green and blue color values.

Detailed Description

Represents a color in Red-Green-Blue space.

Constructor & Destructor Documentation

aiColor3D::aiColor3D ( ) [inline]
aiColor3D::aiColor3D | ( | float | _r,
 |  | float | _g,
 |  | float | _b
 | ) |  | [inline]
aiColor3D::aiColor3D ( float _r ) [inline]
aiColor3D::aiColor3D ( const aiColor3D & o ) [inline]

Member Function Documentation

bool aiColor3D::IsBlack ( ) const [inline]

Check whether a color is black.

bool aiColor3D::operator!= ( const aiColor3D & other ) const [inline]

Component-wise inverse comparison.

aiColor3D aiColor3D::operator* ( const aiColor3D & c ) const [inline]

Component-wise multiplication.

aiColor3D aiColor3D::operator* ( float f ) const [inline]

Multiply with a scalar.

aiColor3D aiColor3D::operator+ ( const aiColor3D & c ) const [inline]

Component-wise addition.

aiColor3D aiColor3D::operator- ( const aiColor3D & c ) const [inline]

Component-wise subtraction.

bool aiColor3D::operator== ( const aiColor3D & other ) const [inline]

Component-wise comparison.

float aiColor3D::operator[] ( unsigned int i ) const [inline]

Access a specific color component.

float& aiColor3D::operator[] ( unsigned int i ) [inline]

Access a specific color component.

Member Data Documentation

float aiColor3D::b
float aiColor3D::g
float aiColor3D::r

Red, green and blue color values.

The documentation for this struct was generated from the following file:
  • types.h


Assimp: aiColor4t< TReal > Class Template Reference

Public Member Functions | Public Attributes
aiColor4t< TReal > Class Template Reference

Represents a color in Red-Green-Blue space including an alpha component. More...

List of all members.

Public Member Functions

aiColor4t ()
aiColor4t (TReal _r, TReal _g, TReal _b, TReal _a)
aiColor4t (const aiColor4t &o)
aiColor4t (TReal _r)
bool | IsBlack () const
check whether a color is (close to) black
bool | operator!= (const aiColor4t &other) const
const aiColor4t & | operator*= (TReal f)
const aiColor4t & | operator+= (const aiColor4t &o)
const aiColor4t & | operator-= (const aiColor4t &o)
const aiColor4t & | operator/= (TReal f)
bool | operator== (const aiColor4t &other) const
TReal | operator[] (unsigned int i) const
TReal & | operator[] (unsigned int i)

Public Attributes

TReal | a
TReal | b
TReal | g
TReal | r

Detailed Description

template<typename TReal>
class aiColor4t< TReal >

Represents a color in Red-Green-Blue space including an alpha component.

Color values range from 0 to 1.

Constructor & Destructor Documentation

template<typename TReal >
aiColor4t< TReal >::aiColor4t ( ) [inline]
template<typename TReal >
aiColor4t< TReal >::aiColor4t | ( | TReal | _r,
 |  | TReal | _g,
 |  | TReal | _b,
 |  | TReal | _a
 | ) |  | [inline]
template<typename TReal >
aiColor4t< TReal >::aiColor4t ( TReal _r ) [inline]
template<typename TReal >
aiColor4t< TReal >::aiColor4t ( const aiColor4t< TReal > & o ) [inline]

Member Function Documentation

template<typename TReal >
bool aiColor4t< TReal >::IsBlack ( ) const [inline]

check whether a color is (close to) black

template<typename TReal >
AI_FORCE_INLINE bool aiColor4t< TReal >::operator!= ( const aiColor4t< TReal > & other ) const
template<typename TReal >
AI_FORCE_INLINE const aiColor4t< TReal > & aiColor4t< TReal >::operator*= ( TReal f )
template<typename TReal >
AI_FORCE_INLINE const aiColor4t< TReal > & aiColor4t< TReal >::operator+= ( const aiColor4t< TReal > & o )
template<typename TReal >
AI_FORCE_INLINE const aiColor4t< TReal > & aiColor4t< TReal >::operator-= ( const aiColor4t< TReal > & o )
template<typename TReal >
AI_FORCE_INLINE const aiColor4t< TReal > & aiColor4t< TReal >::operator/= ( TReal f )
template<typename TReal >
AI_FORCE_INLINE bool aiColor4t< TReal >::operator== ( const aiColor4t< TReal > & other ) const
template<typename TReal >
AI_FORCE_INLINE TReal aiColor4t< TReal >::operator[] ( unsigned int i ) const [inline]
template<typename TReal >
AI_FORCE_INLINE TReal & aiColor4t< TReal >::operator[] ( unsigned int i ) [inline]

Member Data Documentation

template<typename TReal >
TReal aiColor4t< TReal >::a
template<typename TReal >
TReal aiColor4t< TReal >::b
template<typename TReal >
TReal aiColor4t< TReal >::g
template<typename TReal >
TReal aiColor4t< TReal >::r
The documentation for this class was generated from the following files:
  • color4.h
  • color4.inl


Assimp: aiExportDataBlob Struct Reference

Public Member Functions | Public Attributes
aiExportDataBlob Struct Reference

Describes a blob of exported scene data. More...

List of all members.

Public Member Functions

aiExportDataBlob ()
Default constructor.
~aiExportDataBlob ()
Releases the data.

Public Attributes

void * | data
The data.
aiString name
Name of the blob.
aiExportDataBlob * next
Pointer to the next blob in the chain or NULL if there is none.
size_t | size
Size of the data in bytes.

Detailed Description

Describes a blob of exported scene data.

Use aiExportSceneToBlob() to create a blob containing an exported scene. The memory referred by this structure is owned by Assimp. Use #aiReleaseExportedFile() to free its resources. Don't try to free the memory on your side - it will crash for most build configurations due to conflicting heaps.

Blobs can be nested - each blob may reference another blob, which may in turn reference another blob and so on. This is used when exporters write more than one output file for a given aiScene. See the remarks for aiExportDataBlob::name for more information.

Constructor & Destructor Documentation

aiExportDataBlob::aiExportDataBlob ( ) [inline]

Default constructor.

aiExportDataBlob::~aiExportDataBlob ( ) [inline]

Releases the data.

Member Data Documentation

void* aiExportDataBlob::data

The data.

aiString aiExportDataBlob::name

Name of the blob.

An empty string always indicates the first (and primary) blob, which contains the actual file data. Any other blobs are auxiliary files produced by exporters (i.e. material files). Existence of such files depends on the file format. Most formats don't split assets across multiple files.

If used, blob names usually contain the file extension that should be used when writing the data to disc.

aiExportDataBlob* aiExportDataBlob::next

Pointer to the next blob in the chain or NULL if there is none.

size_t aiExportDataBlob::size

Size of the data in bytes.

The documentation for this struct was generated from the following file:
  • cexport.h


Assimp: aiExportFormatDesc Struct Reference

Public Attributes
aiExportFormatDesc Struct Reference

Describes an file format which Assimp can export to. More...

List of all members.

Public Attributes

const char * | description
A short description of the file format to present to users.
const char * | fileExtension
Recommended file extension for the exported file in lower case.
const char * | id
a short string ID to uniquely identify the export format.

Detailed Description

Describes an file format which Assimp can export to.

Use aiGetExportFormatCount() to learn how many export formats the current Assimp build supports and aiGetExportFormatDescription() to retrieve a description of an export format option.

Member Data Documentation

const char* aiExportFormatDesc::description

A short description of the file format to present to users.

Useful if you want to allow the user to select an export format.

const char* aiExportFormatDesc::fileExtension

Recommended file extension for the exported file in lower case.

const char* aiExportFormatDesc::id

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(). Example: "dae" or "obj"

The documentation for this struct was generated from the following file:
  • cexport.h


Assimp: aiFace Struct Reference

Public Member Functions | Public Attributes
aiFace Struct Reference

A single face in a mesh, referring to multiple vertices. More...

List of all members.

Public Member Functions

aiFace ()
Default constructor.
aiFace (const aiFace &o)
Copy constructor. Copy the index array.
bool | operator!= (const aiFace &o) const
Inverse comparison operator.
const aiFace & | operator= (const aiFace &o)
Assignment operator. Copy the index array.
bool | operator== (const aiFace &o) const
Comparison operator.
~aiFace ()
Default destructor. Delete the index array.

Public Attributes

unsigned int * | mIndices
Pointer to the indices array. Size of the array is given in numIndices.
unsigned int | mNumIndices
Number of indices defining this face.

Detailed Description

A single face in a mesh, referring to multiple vertices.

If mNumIndices is 3, we call the face 'triangle', for mNumIndices > 3 it's called 'polygon' (hey, that's just a definition!).
aiMesh::mPrimitiveTypes can be queried to quickly examine which types of primitive are actually present in a mesh. The aiProcess_SortByPType flag executes a special post-processing algorithm which splits meshes with *different* primitive types mixed up (e.g. lines and triangles) in several 'clean' submeshes. Furthermore there is a configuration option ( AI_CONFIG_PP_SBP_REMOVE) to force aiProcess_SortByPType to remove specific kinds of primitives from the imported scene, completely and forever. In many cases you'll probably want to set this setting to

 aiPrimitiveType_LINE|aiPrimitiveType_POINT

Together with the aiProcess_Triangulate flag you can then be sure that aiFace::mNumIndices is always 3.

Note:
Take a look at the Data Structures page for more information on the layout and winding order of a face.

Constructor & Destructor Documentation

aiFace::aiFace ( ) [inline]

Default constructor.

aiFace::~aiFace ( ) [inline]

Default destructor. Delete the index array.

aiFace::aiFace ( const aiFace & o ) [inline]

Copy constructor. Copy the index array.

Member Function Documentation

bool aiFace::operator!= ( const aiFace & o ) const [inline]

Inverse comparison operator.

Checks whether the index array of two faces is NOT identical

const aiFace& aiFace::operator= ( const aiFace & o ) [inline]

Assignment operator. Copy the index array.

bool aiFace::operator== ( const aiFace & o ) const [inline]

Comparison operator.

Checks whether the index array of two faces is identical

Member Data Documentation

unsigned int* aiFace::mIndices

Pointer to the indices array. Size of the array is given in numIndices.

unsigned int aiFace::mNumIndices

Number of indices defining this face.

The maximum value for this member is AI_MAX_FACE_INDICES.

The documentation for this struct was generated from the following file:
  • mesh.h


Assimp: aiFile Struct Reference

Public Attributes
aiFile Struct Reference

C-API: File callbacks. More...

List of all members.

Public Attributes

aiFileTellProc FileSizeProc
Callback to retrieve the size of the file, in bytes.
aiFileFlushProc FlushProc
Callback to flush the file contents.
aiFileReadProc ReadProc
Callback to read from a file.
aiFileSeek SeekProc
Callback to set the current position of the file cursor (fseek())
aiFileTellProc TellProc
Callback to retrieve the current position of the file cursor (ftell())
aiUserData UserData
User-defined, opaque data.
aiFileWriteProc WriteProc
Callback to write to a file.

Detailed Description

C-API: File callbacks.

Actually, it's a data structure to wrap a set of fXXXX (e.g fopen) replacement functions.

The default implementation of the functions utilizes the fXXX functions from the CRT. However, you can supply a custom implementation to Assimp by delivering a custom aiFileIO. Use this to enable reading from other sources, such as ZIP archives or memory locations.

Member Data Documentation

aiFileTellProc aiFile::FileSizeProc

Callback to retrieve the size of the file, in bytes.

aiFileFlushProc aiFile::FlushProc

Callback to flush the file contents.

aiFileReadProc aiFile::ReadProc

Callback to read from a file.

aiFileSeek aiFile::SeekProc

Callback to set the current position of the file cursor (fseek())

aiFileTellProc aiFile::TellProc

Callback to retrieve the current position of the file cursor (ftell())

aiUserData aiFile::UserData

User-defined, opaque data.

aiFileWriteProc aiFile::WriteProc

Callback to write to a file.

The documentation for this struct was generated from the following file:
  • cfileio.h


Assimp: aiFileIO Struct Reference

Public Attributes
aiFileIO Struct Reference

C-API: File system callbacks. More...

List of all members.

Public Attributes

aiFileCloseProc CloseProc
Function used to close an existing file.
aiFileOpenProc OpenProc
Function used to open a new file.
aiUserData UserData
User-defined, opaque data.

Detailed Description

C-API: File system callbacks.

Provided are functions to open and close files. Supply a custom structure to the import function. If you don't, a default implementation is used. Use custom file systems to enable reading from other sources, such as ZIPs or memory locations.

Member Data Documentation

aiFileCloseProc aiFileIO::CloseProc

Function used to close an existing file.

aiFileOpenProc aiFileIO::OpenProc

Function used to open a new file.

aiUserData aiFileIO::UserData

User-defined, opaque data.

The documentation for this struct was generated from the following file:
  • cfileio.h


Assimp: aiImporterDesc Struct Reference

Public Attributes
aiImporterDesc Struct Reference

Meta information about a particular importer. More...

List of all members.

Public Attributes

const char * | mAuthor
Original author (left blank if unknown or whole assimp team)
const char * | mComments
Implementation comments, i.e.
const char * | mFileExtensions
List of file extensions this importer can handle.
unsigned int | mFlags
Any combination of the #aiLoaderFlags enumerated values.
const char * | mMaintainer
Current maintainer, left blank if the author maintains.
unsigned int | mMaxMajor
Maximum format version that can be loaded im major.minor format, both are set to 0 if there is either no version scheme or if the loader doesn't care.
unsigned int | mMaxMinor
unsigned int | mMinMajor
Minimum format version that can be loaded im major.minor format, both are set to 0 if there is either no version scheme or if the loader doesn't care.
unsigned int | mMinMinor
const char * | mName
Full name of the importer (i.e.

Detailed Description

Meta information about a particular importer.

Importers need to fill this structure, but they can freely decide how talkative they are. A common use case for loader meta info is a user interface in which the user can choose between various import/export file formats. Building such an UI by hand means a lot of maintenance as importers/exporters are added to Assimp, so it might be useful to have a common mechanism to query some rough importer characteristics.

Member Data Documentation

const char* aiImporterDesc::mAuthor

Original author (left blank if unknown or whole assimp team)

const char* aiImporterDesc::mComments

Implementation comments, i.e.

unimplemented features

const char* aiImporterDesc::mFileExtensions

List of file extensions this importer can handle.

List entries are separated by space characters. All entries are lower case without a leading dot (i.e. "xml dae" would be a valid value. Note that multiple importers may respond to the same file extension - assimp calls all importers in the order in which they are registered and each importer gets the opportunity to load the file until one importer "claims" the file. Apart from file extension checks, importers typically use other methods to quickly reject files (i.e. magic words) so this does not mean that common or generic file extensions such as XML would be tediously slow.

unsigned int aiImporterDesc::mFlags

Any combination of the #aiLoaderFlags enumerated values.

These flags indicate some characteristics common to many importers.

const char* aiImporterDesc::mMaintainer

Current maintainer, left blank if the author maintains.

unsigned int aiImporterDesc::mMaxMajor

Maximum format version that can be loaded im major.minor format, both are set to 0 if there is either no version scheme or if the loader doesn't care.

Loaders that expect to be forward-compatible to potential future format versions should indicate zero, otherwise they should specify the current maximum version.

unsigned int aiImporterDesc::mMaxMinor
unsigned int aiImporterDesc::mMinMajor

Minimum format version that can be loaded im major.minor format, both are set to 0 if there is either no version scheme or if the loader doesn't care.

unsigned int aiImporterDesc::mMinMinor
const char* aiImporterDesc::mName

Full name of the importer (i.e.

Blender3D importer)

The documentation for this struct was generated from the following file:
  • importerdesc.h


Assimp: aiLight Struct Reference

Public Member Functions | Public Attributes
aiLight Struct Reference

Helper structure to describe a light source. More...

List of all members.

Public Member Functions

aiLight ()

Public Attributes

float | mAngleInnerCone
Inner angle of a spot light's light cone.
float | mAngleOuterCone
Outer angle of a spot light's light cone.
float | mAttenuationConstant
Constant light attenuation factor.
float | mAttenuationLinear
Linear light attenuation factor.
float | mAttenuationQuadratic
Quadratic light attenuation factor.
aiColor3D mColorAmbient
Ambient color of the light source.
aiColor3D mColorDiffuse
Diffuse color of the light source.
aiColor3D mColorSpecular
Specular color of the light source.
aiVector3D mDirection
Direction of the light source in space.
aiString mName
The name of the light source.
aiVector3D mPosition
Position of the light source in space.
aiLightSourceType mType
The type of the light source.

Detailed Description

Helper structure to describe a light source.

Assimp supports multiple sorts of light sources, including directional, point and spot lights. All of them are defined with just a single structure and distinguished by their parameters. Note - some file formats (such as 3DS, ASE) export a "target point" - the point a spot light is looking at (it can even be animated). Assimp writes the target point as a subnode of a spotlights's main node, called "<spotName>.Target". However, this is just additional information then, the transformation tracks of the main node make the spot light already point in the right direction.

Constructor & Destructor Documentation

aiLight::aiLight ( ) [inline]

Member Data Documentation

float aiLight::mAngleInnerCone

Inner angle of a spot light's light cone.

The spot light has maximum influence on objects inside this angle. The angle is given in radians. It is 2PI for point lights and undefined for directional lights.

float aiLight::mAngleOuterCone

Outer angle of a spot light's light cone.

The spot light does not affect objects outside this angle. The angle is given in radians. It is 2PI for point lights and undefined for directional lights. The outer angle must be greater than or equal to the inner angle. It is assumed that the application uses a smooth interpolation between the inner and the outer cone of the spot light.

float aiLight::mAttenuationConstant

Constant light attenuation factor.

The intensity of the light source at a given distance 'd' from the light's position is

  Atten = 1/( att0 + att1 * d + att2 * d*d)

This member corresponds to the att0 variable in the equation. Naturally undefined for directional lights.

float aiLight::mAttenuationLinear

Linear light attenuation factor.

The intensity of the light source at a given distance 'd' from the light's position is

  Atten = 1/( att0 + att1 * d + att2 * d*d)

This member corresponds to the att1 variable in the equation. Naturally undefined for directional lights.

float aiLight::mAttenuationQuadratic

Quadratic light attenuation factor.

The intensity of the light source at a given distance 'd' from the light's position is

  Atten = 1/( att0 + att1 * d + att2 * d*d)

This member corresponds to the att2 variable in the equation. Naturally undefined for directional lights.

aiColor3D aiLight::mColorAmbient

Ambient color of the light source.

The ambient light color is multiplied with the ambient material color to obtain the final color that contributes to the ambient shading term. Most renderers will ignore this value it, is just a remaining of the fixed-function pipeline that is still supported by quite many file formats.

aiColor3D aiLight::mColorDiffuse

Diffuse color of the light source.

The diffuse light color is multiplied with the diffuse material color to obtain the final color that contributes to the diffuse shading term.

aiColor3D aiLight::mColorSpecular

Specular color of the light source.

The specular light color is multiplied with the specular material color to obtain the final color that contributes to the specular shading term.

aiVector3D aiLight::mDirection

Direction of the light source in space.

Relative to the transformation of the node corresponding to the light.

The direction is undefined for point lights. The vector may be normalized, but it needn't.

aiString aiLight::mName

The name of the light source.

There must be a node in the scenegraph with the same name. This node specifies the position of the light in the scene hierarchy and can be animated.

aiVector3D aiLight::mPosition

Position of the light source in space.

Relative to the transformation of the node corresponding to the light.

The position is undefined for directional lights.

aiLightSourceType aiLight::mType

The type of the light source.

aiLightSource_UNDEFINED is not a valid value for this member.

The documentation for this struct was generated from the following file:
  • light.h


Assimp: aiLogStream Struct Reference

Public Attributes
aiLogStream Struct Reference

C-API: Represents a log stream. More...

List of all members.

Public Attributes

aiLogStreamCallback callback
callback to be called
char * user
user data to be passed to the callback

Detailed Description

C-API: Represents a log stream.

A log stream receives all log messages and streams them _somewhere_.

See also:
aiGetPredefinedLogStream
aiAttachLogStream
aiDetachLogStream

Member Data Documentation

aiLogStreamCallback aiLogStream::callback

callback to be called

char* aiLogStream::user

user data to be passed to the callback

The documentation for this struct was generated from the following file:
  • cimport.h


Assimp: aiMaterial Struct Reference

Public Member Functions | Static Public Member Functions | Public Attributes
aiMaterial Struct Reference

Data structure for a material. More...

List of all members.

Public Member Functions

aiReturn | AddBinaryProperty (const void *pInput, unsigned int pSizeInBytes, const char *pKey, unsigned int type, unsigned int index, aiPropertyTypeInfo pType)
Add a property with a given key and type info to the material structure.
aiReturn | AddProperty (const aiString *pInput, const char *pKey, unsigned int type=0, unsigned int index=0)
Add a string property with a given key and type info to the material structure.
template<class TYPE >
aiReturn | AddProperty (const TYPE *pInput, unsigned int pNumValues, const char *pKey, unsigned int type=0, unsigned int index=0)
Add a property with a given key to the material structure.
aiMaterial ()
void | Clear ()
Removes all properties from the material.
template<typename Type >
aiReturn | Get (const char *pKey, unsigned int type, unsigned int idx, Type &pOut) const
Retrieve a Type value with a specific key from the material.
template<typename Type >
aiReturn | Get (const char *pKey, unsigned int type, unsigned int idx, Type *pOut, unsigned int *pMax) const
Retrieve an array of Type values with a specific key from the material.
aiReturn | GetTexture (aiTextureType type, unsigned int index, aiString *path, aiTextureMapping *mapping=NULL, unsigned int *uvindex=NULL, float *blend=NULL, aiTextureOp *op=NULL, aiTextureMapMode *mapmode=NULL) const
Helper function to get all parameters pertaining to a particular texture slot from a material.
unsigned int | GetTextureCount (aiTextureType type) const
Get the number of textures for a particular texture type.
aiReturn | RemoveProperty (const char *pKey, unsigned int type=0, unsigned int index=0)
Remove a given key from the list.
~aiMaterial ()

Static Public Member Functions

static void | CopyPropertyList (aiMaterial *pcDest, const aiMaterial *pcSrc)
Copy the property list of a material.

Public Attributes

unsigned int | mNumAllocated
Storage allocated.
unsigned int | mNumProperties
Number of properties in the data base.
aiMaterialProperty ** | mProperties
List of all material properties loaded.

Detailed Description

Data structure for a material.

Material data is stored using a key-value structure. A single key-value pair is called a 'material property'. C++ users should use the provided member functions of aiMaterial to process material properties, C users have to stick with the aiMaterialGetXXX family of unbound functions. The library defines a set of standard keys (AI_MATKEY_XXX).

Constructor & Destructor Documentation

aiMaterial::aiMaterial ( )
aiMaterial::~aiMaterial ( )

Member Function Documentation

aiReturn aiMaterial::AddBinaryProperty | ( | const void * | pInput,
 |  | unsigned int | pSizeInBytes,
 |  | const char * | pKey,
 |  | unsigned int | type,
 |  | unsigned int | index,
 |  | aiPropertyTypeInfo | pType
 | ) |  |

Add a property with a given key and type info to the material structure.

Parameters:
pInput | Pointer to input data
pSizeInBytes | Size of input data
pKey | Key/Usage of the property (AI_MATKEY_XXX)
type | Set by the AI_MATKEY_XXX macro
index | Set by the AI_MATKEY_XXX macro
pType | Type information hint
aiReturn aiMaterial::AddProperty | ( | const aiString * | pInput,
 |  | const char * | pKey,
 |  | unsigned int | type = 0,
 |  | unsigned int | index = 0
 | ) |  |

Add a string property with a given key and type info to the material structure.

Parameters:
pInput | Input string
pKey | Key/Usage of the property (AI_MATKEY_XXX)
type | Set by the AI_MATKEY_XXX macro
index | Set by the AI_MATKEY_XXX macro
template<class TYPE >
aiReturn aiMaterial::AddProperty | ( | const TYPE * | pInput,
 |  | unsigned int | pNumValues,
 |  | const char * | pKey,
 |  | unsigned int | type = 0,
 |  | unsigned int | index = 0
 | ) |  |

Add a property with a given key to the material structure.

Parameters:
pInput | Pointer to the input data
pNumValues | Number of values in the array
pKey | Key/Usage of the property (AI_MATKEY_XXX)
type | Set by the AI_MATKEY_XXX macro
index | Set by the AI_MATKEY_XXX macro
void aiMaterial::Clear ( )

Removes all properties from the material.

The data array remains allocated so adding new properties is quite fast.

static void aiMaterial::CopyPropertyList | ( | aiMaterial * | pcDest,
 |  | const aiMaterial * | pcSrc
 | ) |  | [static]

Copy the property list of a material.

Parameters:
pcDest | Destination material
pcSrc | Source material
template<typename Type >
aiReturn aiMaterial::Get | ( | const char * | pKey,
 |  | unsigned int | type,
 |  | unsigned int | idx,
 |  | Type * | pOut,
 |  | unsigned int * | pMax
 | ) |  | const

Retrieve an array of Type values with a specific key from the material.

Parameters:
pKey | Key to search for. One of the AI_MATKEY_XXX constants.
type | .. set by AI_MATKEY_XXX
idx | .. set by AI_MATKEY_XXX
pOut | Pointer to a buffer to receive the result.
pMax | Specifies the size of the given buffer, in Type's. Receives the number of values (not bytes!) read. NULL is a valid value for this parameter.
template<typename Type >
aiReturn aiMaterial::Get | ( | const char * | pKey,
 |  | unsigned int | type,
 |  | unsigned int | idx,
 |  | Type & | pOut
 | ) |  | const

Retrieve a Type value with a specific key from the material.

Parameters:
pKey | Key to search for. One of the AI_MATKEY_XXX constants.
type | Specifies the type of the texture to be retrieved ( e.g. diffuse, specular, height map ...)
idx | Index of the texture to be retrieved.
pOut | Reference to receive the output value
aiReturn aiMaterial::GetTexture | ( | aiTextureType | type,
 |  | unsigned int | index,
 |  | aiString * | path,
 |  | aiTextureMapping * | mapping = NULL,
 |  | unsigned int * | uvindex = NULL,
 |  | float * | blend = NULL,
 |  | aiTextureOp * | op = NULL,
 |  | aiTextureMapMode * | mapmode = NULL
 | ) |  | const

Helper function to get all parameters pertaining to a particular texture slot from a material.

This function is provided just for convenience, you could also read the single material properties manually.

Parameters:
type | Specifies the type of the texture to be retrieved ( e.g. diffuse, specular, height map ...)
index | Index of the texture to be retrieved. The function fails if there is no texture of that type with this index. GetTextureCount() can be used to determine the number of textures per texture type.
path | Receives the path to the texture. NULL is a valid value.
mapping | The texture mapping. NULL is allowed as value.
uvindex | Receives the UV index of the texture. NULL is a valid value.
blend | Receives the blend factor for the texture NULL is a valid value.
op | Receives the texture operation to be performed between this texture and the previous texture. NULL is allowed as value.
mapmode | Receives the mapping modes to be used for the texture. The parameter may be NULL but if it is a valid pointer it MUST point to an array of 3 aiTextureMapMode's (one for each axis: UVW order (=XYZ)).
unsigned int aiMaterial::GetTextureCount ( aiTextureType type ) const

Get the number of textures for a particular texture type.

Parameters:
type Texture type to check for
Returns:
Number of textures for this type.
Note:
A texture can be easily queried using GetTexture()
aiReturn aiMaterial::RemoveProperty | ( | const char * | pKey,
 |  | unsigned int | type = 0,
 |  | unsigned int | index = 0
 | ) |  |

Remove a given key from the list.

The function fails if the key isn't found

Parameters:
pKey Key to be deleted

Member Data Documentation

unsigned int aiMaterial::mNumAllocated

Storage allocated.

unsigned int aiMaterial::mNumProperties

Number of properties in the data base.

aiMaterialProperty** aiMaterial::mProperties

List of all material properties loaded.

The documentation for this struct was generated from the following file:
  • material.h


Assimp: aiMatrix3x3t< TReal > Class Template Reference

Public Member Functions | Static Public Member Functions | Public Attributes
aiMatrix3x3t< TReal > Class Template Reference

Represents a row-major 3x3 matrix. More...

List of all members.

Public Member Functions

aiMatrix3x3t ()
aiMatrix3x3t (TReal _a1, TReal _a2, TReal _a3, TReal _b1, TReal _b2, TReal _b3, TReal _c1, TReal _c2, TReal _c3)
aiMatrix3x3t (const aiMatrix4x4t< TReal > &pMatrix)
Construction from a 4x4 matrix.
TReal | Determinant () const
aiMatrix3x3t & Inverse ()
Invert the matrix.
template<typename TOther >
operator aiMatrix3x3t< TOther > () const
bool | operator!= (const aiMatrix4x4t< TReal > m) const
aiMatrix3x3t | operator* (const aiMatrix3x3t &m) const
aiMatrix3x3t & | operator*= (const aiMatrix3x3t &m)
bool | operator== (const aiMatrix4x4t< TReal > m) const
const TReal * | operator[] (unsigned int p_iIndex) const
TReal * | operator[] (unsigned int p_iIndex)
aiMatrix3x3t & Transpose ()
Transpose the matrix.

Static Public Member Functions

static aiMatrix3x3t & | FromToMatrix (const aiVector3t< TReal > &from, const aiVector3t< TReal > &to, aiMatrix3x3t &out)
A function for creating a rotation matrix that rotates a vector called "from" into another vector called "to".
static aiMatrix3x3t & | Rotation (TReal a, const aiVector3t< TReal > &axis, aiMatrix3x3t &out)
Returns a rotation matrix for a rotation around an arbitrary axis.
static aiMatrix3x3t & | RotationZ (TReal a, aiMatrix3x3t &out)
Returns a rotation matrix for a rotation around z.
static aiMatrix3x3t & | Translation (const aiVector2t< TReal > &v, aiMatrix3x3t &out)
Returns a translation matrix.

Public Attributes

TReal | a1
TReal | a2
TReal | a3
TReal | b1
TReal | b2
TReal | b3
TReal | c1
TReal | c2
TReal | c3

Detailed Description

template<typename TReal>
class aiMatrix3x3t< TReal >

Represents a row-major 3x3 matrix.

There's much confusion about matrix layouts (column vs. row order). This is *always* a row-major matrix. Not even with the aiProcess_ConvertToLeftHanded flag, which absolutely does not affect matrix order - it just affects the handedness of the coordinate system defined thereby.

Constructor & Destructor Documentation

template<typename TReal >
aiMatrix3x3t< TReal >::aiMatrix3x3t ( ) [inline]
template<typename TReal >
aiMatrix3x3t< TReal >::aiMatrix3x3t | ( | TReal | _a1,
 |  | TReal | _a2,
 |  | TReal | _a3,
 |  | TReal | _b1,
 |  | TReal | _b2,
 |  | TReal | _b3,
 |  | TReal | _c1,
 |  | TReal | _c2,
 |  | TReal | _c3
 | ) |  | [inline]
template<typename TReal >
aiMatrix3x3t< TReal >::aiMatrix3x3t ( const aiMatrix4x4t< TReal > & pMatrix ) [inline, explicit]

Construction from a 4x4 matrix.

The remaining parts of the matrix are ignored.

Member Function Documentation

template<typename TReal >
TReal aiMatrix3x3t< TReal >::Determinant ( ) const [inline]
template<typename TReal >
aiMatrix3x3t< TReal > & aiMatrix3x3t< TReal >::FromToMatrix | ( | const aiVector3t< TReal > & | from,
 |  | const aiVector3t< TReal > & | to,
 |  | aiMatrix3x3t< TReal > & | out
 | ) |  | [inline, static]

A function for creating a rotation matrix that rotates a vector called "from" into another vector called "to".

Input : from[3], to[3] which both must be *normalized* non-zero vectors Output: mtx[3][3] -- a 3x3 matrix in colum-major form Authors: Tomas Möller, John Hughes "Efficiently Building a Matrix to Rotate One Vector to Another" Journal of Graphics Tools, 4(4):1-4, 1999

template<typename TReal >
aiMatrix3x3t< TReal > & aiMatrix3x3t< TReal >::Inverse ( ) [inline]

Invert the matrix.

If the matrix is not invertible all elements are set to qnan. Beware, use (f != f) to check whether a TReal f is qnan.

template<typename TReal >
template<typename TOther >
aiMatrix3x3t< TReal >::operator aiMatrix3x3t< TOther > ( ) const
template<typename TReal >
bool aiMatrix3x3t< TReal >::operator!= ( const aiMatrix4x4t< TReal > m ) const [inline]
template<typename TReal >
aiMatrix3x3t< TReal > aiMatrix3x3t< TReal >::operator* ( const aiMatrix3x3t< TReal > & m ) const [inline]
template<typename TReal >
aiMatrix3x3t< TReal > & aiMatrix3x3t< TReal >::operator*= ( const aiMatrix3x3t< TReal > & m ) [inline]
template<typename TReal >
bool aiMatrix3x3t< TReal >::operator== ( const aiMatrix4x4t< TReal > m ) const [inline]
template<typename TReal >
const TReal * aiMatrix3x3t< TReal >::operator[] ( unsigned int p_iIndex ) const [inline]
template<typename TReal >
TReal * aiMatrix3x3t< TReal >::operator[] ( unsigned int p_iIndex ) [inline]
template<typename TReal >
aiMatrix3x3t< TReal > & aiMatrix3x3t< TReal >::Rotation | ( | TReal | a,
 |  | const aiVector3t< TReal > & | axis,
 |  | aiMatrix3x3t< TReal > & | out
 | ) |  | [inline, static]

Returns a rotation matrix for a rotation around an arbitrary axis.

Parameters:
a | Rotation angle, in radians
axis | Axis to rotate around
out | To be filled
template<typename TReal >
aiMatrix3x3t< TReal > & aiMatrix3x3t< TReal >::RotationZ | ( | TReal | a,
 |  | aiMatrix3x3t< TReal > & | out
 | ) |  | [inline, static]

Returns a rotation matrix for a rotation around z.

Parameters:
a | Rotation angle, in radians
out | Receives the output matrix
Returns:
Reference to the output matrix
template<typename TReal >
aiMatrix3x3t< TReal > & aiMatrix3x3t< TReal >::Translation | ( | const aiVector2t< TReal > & | v,
 |  | aiMatrix3x3t< TReal > & | out
 | ) |  | [inline, static]

Returns a translation matrix.

Parameters:
v | Translation vector
out | Receives the output matrix
Returns:
Reference to the output matrix
template<typename TReal >
aiMatrix3x3t< TReal > & aiMatrix3x3t< TReal >::Transpose ( ) [inline]

Transpose the matrix.

Member Data Documentation

template<typename TReal >
TReal aiMatrix3x3t< TReal >::a1
template<typename TReal >
TReal aiMatrix3x3t< TReal >::a2
template<typename TReal >
TReal aiMatrix3x3t< TReal >::a3
template<typename TReal >
TReal aiMatrix3x3t< TReal >::b1
template<typename TReal >
TReal aiMatrix3x3t< TReal >::b2
template<typename TReal >
TReal aiMatrix3x3t< TReal >::b3
template<typename TReal >
TReal aiMatrix3x3t< TReal >::c1
template<typename TReal >
TReal aiMatrix3x3t< TReal >::c2
template<typename TReal >
TReal aiMatrix3x3t< TReal >::c3
The documentation for this class was generated from the following files:
  • matrix3x3.h
  • matrix3x3.inl


Assimp: aiMatrix4x4t< TReal > Class Template Reference

Public Member Functions | Static Public Member Functions | Public Attributes
aiMatrix4x4t< TReal > Class Template Reference

Represents a row-major 4x4 matrix, use this for homogeneous coordinates. More...

List of all members.

Public Member Functions

aiMatrix4x4t ()
set to identity
aiMatrix4x4t (TReal _a1, TReal _a2, TReal _a3, TReal _a4, TReal _b1, TReal _b2, TReal _b3, TReal _b4, TReal _c1, TReal _c2, TReal _c3, TReal _c4, TReal _d1, TReal _d2, TReal _d3, TReal _d4)
construction from single values
aiMatrix4x4t (const aiMatrix3x3t< TReal > &m)
construction from 3x3 matrix, remaining elements are set to identity
void | Decompose (aiVector3t< TReal > &scaling, aiQuaterniont< TReal > &rotation, aiVector3t< TReal > &position) const
Decompose a trafo matrix into its original components.
void | DecomposeNoScaling (aiQuaterniont< TReal > &rotation, aiVector3t< TReal > &position) const
Decompose a trafo matrix with no scaling into its original components.
TReal | Determinant () const
aiMatrix4x4t & | FromEulerAnglesXYZ (TReal x, TReal y, TReal z)
Creates a trafo matrix from a set of euler angles.
aiMatrix4x4t & | FromEulerAnglesXYZ (const aiVector3t< TReal > &blubb)
aiMatrix4x4t & Inverse ()
Invert the matrix.
bool | IsIdentity () const
Returns true of the matrix is the identity matrix.
template<typename TOther >
operator aiMatrix4x4t< TOther > () const
bool | operator!= (const aiMatrix4x4t m) const
aiMatrix4x4t | operator* (const aiMatrix4x4t &m) const
aiMatrix4x4t & | operator*= (const aiMatrix4x4t &m)
bool | operator== (const aiMatrix4x4t m) const
const TReal * | operator[] (unsigned int p_iIndex) const
TReal * | operator[] (unsigned int p_iIndex)
aiMatrix4x4t & Transpose ()
Transpose the matrix.

Static Public Member Functions

static aiMatrix4x4t & | FromToMatrix (const aiVector3t< TReal > &from, const aiVector3t< TReal > &to, aiMatrix4x4t &out)
A function for creating a rotation matrix that rotates a vector called "from" into another vector called "to".
static aiMatrix4x4t & | Rotation (TReal a, const aiVector3t< TReal > &axis, aiMatrix4x4t &out)
Returns a rotation matrix for a rotation around an arbitrary axis.
static aiMatrix4x4t & | RotationX (TReal a, aiMatrix4x4t &out)
Returns a rotation matrix for a rotation around the x axis.
static aiMatrix4x4t & | RotationY (TReal a, aiMatrix4x4t &out)
Returns a rotation matrix for a rotation around the y axis.
static aiMatrix4x4t & | RotationZ (TReal a, aiMatrix4x4t &out)
Returns a rotation matrix for a rotation around the z axis.
static aiMatrix4x4t & | Scaling (const aiVector3t< TReal > &v, aiMatrix4x4t &out)
Returns a scaling matrix.
static aiMatrix4x4t & | Translation (const aiVector3t< TReal > &v, aiMatrix4x4t &out)
Returns a translation matrix.

Public Attributes

TReal | a1
TReal | a2
TReal | a3
TReal | a4
TReal | b1
TReal | b2
TReal | b3
TReal | b4
TReal | c1
TReal | c2
TReal | c3
TReal | c4
TReal | d1
TReal | d2
TReal | d3
TReal | d4

Detailed Description

template<typename TReal>
class aiMatrix4x4t< TReal >

Represents a row-major 4x4 matrix, use this for homogeneous coordinates.

There's much confusion about matrix layouts (column vs. row order). This is *always* a row-major matrix. Not even with the aiProcess_ConvertToLeftHanded flag, which absolutely does not affect matrix order - it just affects the handedness of the coordinate system defined thereby.

Constructor & Destructor Documentation

template<typename TReal >
aiMatrix4x4t< TReal >::aiMatrix4x4t ( )

set to identity

template<typename TReal>
aiMatrix4x4t< TReal >::aiMatrix4x4t | ( | TReal | _a1,
 |  | TReal | _a2,
 |  | TReal | _a3,
 |  | TReal | _a4,
 |  | TReal | _b1,
 |  | TReal | _b2,
 |  | TReal | _b3,
 |  | TReal | _b4,
 |  | TReal | _c1,
 |  | TReal | _c2,
 |  | TReal | _c3,
 |  | TReal | _c4,
 |  | TReal | _d1,
 |  | TReal | _d2,
 |  | TReal | _d3,
 |  | TReal | _d4
 | ) |  |

construction from single values

template<typename TReal>
aiMatrix4x4t< TReal >::aiMatrix4x4t ( const aiMatrix3x3t< TReal > & m ) [inline, explicit]

construction from 3x3 matrix, remaining elements are set to identity

Member Function Documentation

template<typename TReal>
void aiMatrix4x4t< TReal >::Decompose | ( | aiVector3t< TReal > & | scaling,
 |  | aiQuaterniont< TReal > & | rotation,
 |  | aiVector3t< TReal > & | position
 | ) |  | const [inline]

Decompose a trafo matrix into its original components.

Parameters:
scaling | Receives the output scaling for the x,y,z axes
rotation | Receives the output rotation as a hamilton quaternion
position | Receives the output position for the x,y,z axes
template<typename TReal>
void aiMatrix4x4t< TReal >::DecomposeNoScaling | ( | aiQuaterniont< TReal > & | rotation,
 |  | aiVector3t< TReal > & | position
 | ) |  | const [inline]

Decompose a trafo matrix with no scaling into its original components.

Parameters:
rotation | Receives the output rotation as a hamilton quaternion
position | Receives the output position for the x,y,z axes
template<typename TReal >
TReal aiMatrix4x4t< TReal >::Determinant ( ) const [inline]
template<typename TReal>
aiMatrix4x4t< TReal > & aiMatrix4x4t< TReal >::FromEulerAnglesXYZ | ( | TReal | x,
 |  | TReal | y,
 |  | TReal | z
 | ) |  | [inline]

Creates a trafo matrix from a set of euler angles.

Parameters:
x | Rotation angle for the x-axis, in radians
y | Rotation angle for the y-axis, in radians
z | Rotation angle for the z-axis, in radians
template<typename TReal>
aiMatrix4x4t< TReal > & aiMatrix4x4t< TReal >::FromEulerAnglesXYZ ( const aiVector3t< TReal > & blubb ) [inline]
template<typename TReal>
aiMatrix4x4t< TReal > & aiMatrix4x4t< TReal >::FromToMatrix | ( | const aiVector3t< TReal > & | from,
 |  | const aiVector3t< TReal > & | to,
 |  | aiMatrix4x4t< TReal > & | out
 | ) |  | [inline, static]

A function for creating a rotation matrix that rotates a vector called "from" into another vector called "to".

Input : from[3], to[3] which both must be *normalized* non-zero vectors Output: mtx[3][3] -- a 3x3 matrix in colum-major form Authors: Tomas Möller, John Hughes "Efficiently Building a Matrix to Rotate One Vector to Another" Journal of Graphics Tools, 4(4):1-4, 1999

template<typename TReal >
aiMatrix4x4t< TReal > & aiMatrix4x4t< TReal >::Inverse ( ) [inline]

Invert the matrix.

If the matrix is not invertible all elements are set to qnan. Beware, use (f != f) to check whether a TReal f is qnan.

template<typename TReal >
bool aiMatrix4x4t< TReal >::IsIdentity ( ) const [inline]

Returns true of the matrix is the identity matrix.

The check is performed against a not so small epsilon.

template<typename TReal >
template<typename TOther >
aiMatrix4x4t< TReal >::operator aiMatrix4x4t< TOther > ( ) const
template<typename TReal >
bool aiMatrix4x4t< TReal >::operator!= ( const aiMatrix4x4t< TReal > m ) const [inline]
template<typename TReal >
aiMatrix4x4t< TReal > aiMatrix4x4t< TReal >::operator* ( const aiMatrix4x4t< TReal > & m ) const [inline]
template<typename TReal >
aiMatrix4x4t< TReal > & aiMatrix4x4t< TReal >::operator*= ( const aiMatrix4x4t< TReal > & m ) [inline]
template<typename TReal >
bool aiMatrix4x4t< TReal >::operator== ( const aiMatrix4x4t< TReal > m ) const [inline]
template<typename TReal >
const TReal * aiMatrix4x4t< TReal >::operator[] ( unsigned int p_iIndex ) const [inline]
template<typename TReal >
TReal * aiMatrix4x4t< TReal >::operator[] ( unsigned int p_iIndex ) [inline]
template<typename TReal>
aiMatrix4x4t< TReal > & aiMatrix4x4t< TReal >::Rotation | ( | TReal | a,
 |  | const aiVector3t< TReal > & | axis,
 |  | aiMatrix4x4t< TReal > & | out
 | ) |  | [inline, static]

Returns a rotation matrix for a rotation around an arbitrary axis.

Parameters:
a | Rotation angle, in radians
axis | Rotation axis, should be a normalized vector.
out | Receives the output matrix
Returns:
Reference to the output matrix
template<typename TReal>
aiMatrix4x4t< TReal > & aiMatrix4x4t< TReal >::RotationX | ( | TReal | a,
 |  | aiMatrix4x4t< TReal > & | out
 | ) |  | [inline, static]

Returns a rotation matrix for a rotation around the x axis.

Parameters:
a | Rotation angle, in radians
out | Receives the output matrix
Returns:
Reference to the output matrix
template<typename TReal>
aiMatrix4x4t< TReal > & aiMatrix4x4t< TReal >::RotationY | ( | TReal | a,
 |  | aiMatrix4x4t< TReal > & | out
 | ) |  | [inline, static]

Returns a rotation matrix for a rotation around the y axis.

Parameters:
a | Rotation angle, in radians
out | Receives the output matrix
Returns:
Reference to the output matrix
template<typename TReal>
aiMatrix4x4t< TReal > & aiMatrix4x4t< TReal >::RotationZ | ( | TReal | a,
 |  | aiMatrix4x4t< TReal > & | out
 | ) |  | [inline, static]

Returns a rotation matrix for a rotation around the z axis.

Parameters:
a | Rotation angle, in radians
out | Receives the output matrix
Returns:
Reference to the output matrix
template<typename TReal>
aiMatrix4x4t< TReal > & aiMatrix4x4t< TReal >::Scaling | ( | const aiVector3t< TReal > & | v,
 |  | aiMatrix4x4t< TReal > & | out
 | ) |  | [inline, static]

Returns a scaling matrix.

Parameters:
v | Scaling vector
out | Receives the output matrix
Returns:
Reference to the output matrix
template<typename TReal>
aiMatrix4x4t< TReal > & aiMatrix4x4t< TReal >::Translation | ( | const aiVector3t< TReal > & | v,
 |  | aiMatrix4x4t< TReal > & | out
 | ) |  | [inline, static]

Returns a translation matrix.

Parameters:
v | Translation vector
out | Receives the output matrix
Returns:
Reference to the output matrix
template<typename TReal >
aiMatrix4x4t< TReal > & aiMatrix4x4t< TReal >::Transpose ( ) [inline]

Transpose the matrix.

Member Data Documentation

template<typename TReal>
TReal aiMatrix4x4t< TReal >::a1
template<typename TReal>
TReal aiMatrix4x4t< TReal >::a2
template<typename TReal>
TReal aiMatrix4x4t< TReal >::a3
template<typename TReal>
TReal aiMatrix4x4t< TReal >::a4
template<typename TReal>
TReal aiMatrix4x4t< TReal >::b1
template<typename TReal>
TReal aiMatrix4x4t< TReal >::b2
template<typename TReal>
TReal aiMatrix4x4t< TReal >::b3
template<typename TReal>
TReal aiMatrix4x4t< TReal >::b4
template<typename TReal>
TReal aiMatrix4x4t< TReal >::c1
template<typename TReal>
TReal aiMatrix4x4t< TReal >::c2
template<typename TReal>
TReal aiMatrix4x4t< TReal >::c3
template<typename TReal>
TReal aiMatrix4x4t< TReal >::c4
template<typename TReal>
TReal aiMatrix4x4t< TReal >::d1
template<typename TReal>
TReal aiMatrix4x4t< TReal >::d2
template<typename TReal>
TReal aiMatrix4x4t< TReal >::d3
template<typename TReal>
TReal aiMatrix4x4t< TReal >::d4
The documentation for this class was generated from the following files:
  • matrix4x4.h
  • matrix4x4.inl


Assimp: aiMesh Struct Reference

Public Member Functions | Public Attributes
aiMesh Struct Reference

A mesh represents a geometry or model with a single material. More...

List of all members.

Public Member Functions

aiMesh ()
Default constructor. Initializes all members to 0.
unsigned int | GetNumColorChannels () const
Get the number of vertex color channels the mesh contains.
unsigned int | GetNumUVChannels () const
Get the number of UV channels the mesh contains.
bool | HasBones () const
Check whether the mesh contains bones.
bool | HasFaces () const
Check whether the mesh contains faces.
bool | HasNormals () const
Check whether the mesh contains normal vectors.
bool | HasPositions () const
Check whether the mesh contains positions.
bool | HasTangentsAndBitangents () const
Check whether the mesh contains tangent and bitangent vectors It is not possible that it contains tangents and no bitangents (or the other way round).
bool | HasTextureCoords (unsigned int pIndex) const
Check whether the mesh contains a texture coordinate set.
bool | HasVertexColors (unsigned int pIndex) const
Check whether the mesh contains a vertex color set.
~aiMesh ()
Deletes all storage allocated for the mesh.

Public Attributes

aiAnimMesh ** mAnimMeshes
NOT CURRENTLY IN USE.
aiVector3D * mBitangents
Vertex bitangents.
aiBone ** mBones
The bones of this mesh.
aiColor4D * | mColors [AI_MAX_NUMBER_OF_COLOR_SETS]
Vertex color sets.
aiFace * mFaces
The faces the mesh is constructed from.
unsigned int | mMaterialIndex
The material used by this mesh.
aiString mName
Name of the mesh.
aiVector3D * mNormals
Vertex normals.
unsigned int | mNumAnimMeshes
NOT CURRENTLY IN USE.
unsigned int | mNumBones
The number of bones this mesh contains.
unsigned int | mNumFaces
The number of primitives (triangles, polygons, lines) in this mesh.
unsigned int | mNumUVComponents [AI_MAX_NUMBER_OF_TEXTURECOORDS]
Specifies the number of components for a given UV channel.
unsigned int | mNumVertices
The number of vertices in this mesh.
unsigned int | mPrimitiveTypes
Bitwise combination of the members of the aiPrimitiveType enum.
aiVector3D * mTangents
Vertex tangents.
aiVector3D * | mTextureCoords [AI_MAX_NUMBER_OF_TEXTURECOORDS]
Vertex texture coords, also known as UV channels.
aiVector3D * mVertices
Vertex positions.

Detailed Description

A mesh represents a geometry or model with a single material.

It usually consists of a number of vertices and a series of primitives/faces referencing the vertices. In addition there might be a series of bones, each of them addressing a number of vertices with a certain weight. Vertex data is presented in channels with each channel containing a single per-vertex information such as a set of texture coords or a normal vector. If a data pointer is non-null, the corresponding data stream is present. From C++-programs you can also use the comfort functions Has*() to test for the presence of various data streams.

A Mesh uses only a single material which is referenced by a material ID.

Note:
The mPositions member is usually not optional. However, vertex positions *could* be missing if the #AI_SCENE_FLAGS_INCOMPLETE flag is set in
 aiScene::mFlags

Constructor & Destructor Documentation

aiMesh::aiMesh ( ) [inline]

Default constructor. Initializes all members to 0.

aiMesh::~aiMesh ( ) [inline]

Deletes all storage allocated for the mesh.

Member Function Documentation

unsigned int aiMesh::GetNumColorChannels ( ) const [inline]

Get the number of vertex color channels the mesh contains.

unsigned int aiMesh::GetNumUVChannels ( ) const [inline]

Get the number of UV channels the mesh contains.

bool aiMesh::HasBones ( ) const [inline]

Check whether the mesh contains bones.

bool aiMesh::HasFaces ( ) const [inline]

Check whether the mesh contains faces.

If no special scene flags are set this should always return true

bool aiMesh::HasNormals ( ) const [inline]

Check whether the mesh contains normal vectors.

bool aiMesh::HasPositions ( ) const [inline]

Check whether the mesh contains positions.

Provided no special scene flags are set (such as #AI_SCENE_FLAGS_ANIM_SKELETON_ONLY), this will always be true

bool aiMesh::HasTangentsAndBitangents ( ) const [inline]

Check whether the mesh contains tangent and bitangent vectors It is not possible that it contains tangents and no bitangents (or the other way round).

The existence of one of them implies that the second is there, too.

bool aiMesh::HasTextureCoords ( unsigned int pIndex ) const [inline]

Check whether the mesh contains a texture coordinate set.

Parameters:
pIndex Index of the texture coordinates set
bool aiMesh::HasVertexColors ( unsigned int pIndex ) const [inline]

Check whether the mesh contains a vertex color set.

Parameters:
pIndex Index of the vertex color set

Member Data Documentation

aiAnimMesh** aiMesh::mAnimMeshes

NOT CURRENTLY IN USE.

Attachment meshes for this mesh, for vertex-based animation. Attachment meshes carry replacement data for some of the mesh'es vertex components (usually positions, normals).

aiVector3D* aiMesh::mBitangents

Vertex bitangents.

The bitangent of a vertex points in the direction of the positive Y texture axis. The array contains normalized vectors, NULL if not present. The array is mNumVertices in size.

Note:
If the mesh contains tangents, it automatically also contains bitangents.
aiBone** aiMesh::mBones

The bones of this mesh.

A bone consists of a name by which it can be found in the frame hierarchy and a set of vertex weights.

aiColor4D* aiMesh::mColors[AI_MAX_NUMBER_OF_COLOR_SETS]

Vertex color sets.

A mesh may contain 0 to AI_MAX_NUMBER_OF_COLOR_SETS vertex colors per vertex. NULL if not present. Each array is mNumVertices in size if present.

aiFace* aiMesh::mFaces

The faces the mesh is constructed from.

Each face refers to a number of vertices by their indices. This array is always present in a mesh, its size is given in mNumFaces. If the #AI_SCENE_FLAGS_NON_VERBOSE_FORMAT is NOT set each face references an unique set of vertices.

unsigned int aiMesh::mMaterialIndex

The material used by this mesh.

A mesh does use only a single material. If an imported model uses multiple materials, the import splits up the mesh. Use this value as index into the scene's material list.

aiString aiMesh::mName

Name of the mesh.

Meshes can be named, but this is not a requirement and leaving this field empty is totally fine. There are mainly three uses for mesh names:

  • some formats name nodes and meshes independently.
  • importers tend to split meshes up to meet the one-material-per-mesh requirement. Assigning the same (dummy) name to each of the result meshes aids the caller at recovering the original mesh partitioning.
  • Vertex animations refer to meshes by their names.
aiVector3D* aiMesh::mNormals

Vertex normals.

The array contains normalized vectors, NULL if not present. The array is mNumVertices in size. Normals are undefined for point and line primitives. A mesh consisting of points and lines only may not have normal vectors. Meshes with mixed primitive types (i.e. lines and triangles) may have normals, but the normals for vertices that are only referenced by point or line primitives are undefined and set to QNaN (WARN: qNaN compares to inequal to *everything*, even to qNaN itself. Using code like this to check whether a field is qnan is:

 #define IS_QNAN(f) (f != f)

still dangerous because even 1.f == 1.f could evaluate to false! ( remember the subtleties of IEEE754 artithmetics). Use stuff like fpclassify instead.

Note:
Normal vectors computed by Assimp are always unit-length. However, this needn't apply for normals that have been taken directly from the model file.
unsigned int aiMesh::mNumAnimMeshes

NOT CURRENTLY IN USE.

The number of attachment meshes

unsigned int aiMesh::mNumBones

The number of bones this mesh contains.

Can be 0, in which case the mBones array is NULL.

unsigned int aiMesh::mNumFaces

The number of primitives (triangles, polygons, lines) in this mesh.

This is also the size of the mFaces array. The maximum value for this member is AI_MAX_FACES.

unsigned int aiMesh::mNumUVComponents[AI_MAX_NUMBER_OF_TEXTURECOORDS]

Specifies the number of components for a given UV channel.

Up to three channels are supported (UVW, for accessing volume or cube maps). If the value is 2 for a given channel n, the component p.z of mTextureCoords[n][p] is set to 0.0f. If the value is 1 for a given channel, p.y is set to 0.0f, too.

Note:
4D coords are not supported
unsigned int aiMesh::mNumVertices

The number of vertices in this mesh.

This is also the size of all of the per-vertex data arrays. The maximum value for this member is AI_MAX_VERTICES.

unsigned int aiMesh::mPrimitiveTypes

Bitwise combination of the members of the aiPrimitiveType enum.

This specifies which types of primitives are present in the mesh. The "SortByPrimitiveType"-Step can be used to make sure the output meshes consist of one primitive type each.

aiVector3D* aiMesh::mTangents

Vertex tangents.

The tangent of a vertex points in the direction of the positive X texture axis. The array contains normalized vectors, NULL if not present. The array is mNumVertices in size. A mesh consisting of points and lines only may not have normal vectors. Meshes with mixed primitive types (i.e. lines and triangles) may have normals, but the normals for vertices that are only referenced by point or line primitives are undefined and set to qNaN. See the mNormals member for a detailled discussion of qNaNs.

Note:
If the mesh contains tangents, it automatically also contains bitangents.
aiVector3D* aiMesh::mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS]

Vertex texture coords, also known as UV channels.

A mesh may contain 0 to AI_MAX_NUMBER_OF_TEXTURECOORDS per vertex. NULL if not present. The array is mNumVertices in size.

aiVector3D* aiMesh::mVertices

Vertex positions.

This array is always present in a mesh. The array is mNumVertices in size.

The documentation for this struct was generated from the following file:
  • mesh.h


Assimp: aiMeshAnim Struct Reference

Public Member Functions | Public Attributes
aiMeshAnim Struct Reference

Describes vertex-based animations for a single mesh or a group of meshes. More...

List of all members.

Public Member Functions

aiMeshAnim ()
~aiMeshAnim ()

Public Attributes

aiMeshKey * mKeys
Key frames of the animation.
aiString mName
Name of the mesh to be animated.
unsigned int mNumKeys
Size of the mKeys array.

Detailed Description

Describes vertex-based animations for a single mesh or a group of meshes.

Meshes carry the animation data for each frame in their aiMesh::mAnimMeshes array. The purpose of aiMeshAnim is to define keyframes linking each mesh attachment to a particular point in time.

Constructor & Destructor Documentation

aiMeshAnim::aiMeshAnim ( ) [inline]
aiMeshAnim::~aiMeshAnim ( ) [inline]

Member Data Documentation

aiMeshKey* aiMeshAnim::mKeys

Key frames of the animation.

May not be NULL.

aiString aiMeshAnim::mName

Name of the mesh to be animated.

An empty string is not allowed, animated meshes need to be named (not necessarily uniquely, the name can basically serve as wildcard to select a group of meshes with similar animation setup)

unsigned int aiMeshAnim::mNumKeys

Size of the mKeys array.

Must be 1, at least.

The documentation for this struct was generated from the following file:
  • anim.h


Assimp: aiMeshKey Struct Reference

Public Types | Public Member Functions | Public Attributes
aiMeshKey Struct Reference

Binds a anim mesh to a specific point in time. More...

List of all members.

Public Types

typedef unsigned int | elem_type

Public Member Functions

aiMeshKey ()
aiMeshKey (double time, const unsigned int value)
Construction from a given time and key value.
bool | operator!= (const aiMeshKey &o) const
bool | operator< (const aiMeshKey &o) const
bool | operator== (const aiMeshKey &o) const
bool | operator> (const aiMeshKey &o) const

Public Attributes

double | mTime
The time of this key.
unsigned int | mValue
Index into the aiMesh::mAnimMeshes array of the mesh coresponding to the aiMeshAnim hosting this key frame.

Detailed Description

Binds a anim mesh to a specific point in time.

Member Typedef Documentation

typedef unsigned int aiMeshKey::elem_type

Constructor & Destructor Documentation

aiMeshKey::aiMeshKey ( ) [inline]
aiMeshKey::aiMeshKey | ( | double | time,
 |  | const unsigned int | value
 | ) |  | [inline]

Construction from a given time and key value.

Member Function Documentation

bool aiMeshKey::operator!= ( const aiMeshKey & o ) const [inline]
bool aiMeshKey::operator< ( const aiMeshKey & o ) const [inline]
bool aiMeshKey::operator== ( const aiMeshKey & o ) const [inline]
bool aiMeshKey::operator> ( const aiMeshKey & o ) const [inline]

Member Data Documentation

double aiMeshKey::mTime

The time of this key.

unsigned int aiMeshKey::mValue

Index into the aiMesh::mAnimMeshes array of the mesh coresponding to the aiMeshAnim hosting this key frame.

The referenced anim mesh is evaluated according to the rules defined in the docs for aiAnimMesh.

The documentation for this struct was generated from the following file:
  • anim.h


Assimp: aiNode Struct Reference

Public Member Functions | Public Attributes
aiNode Struct Reference

A node in the imported hierarchy. More...

List of all members.

Public Member Functions

aiNode ()
Constructor.
aiNode (const std::string &name)
Construction from a specific name.
aiNode * | FindNode (const aiString &name)
Searches for a node with a specific name, beginning at this nodes.
aiNode * | FindNode (const char *name)

~aiNode ()
Destructor.

Public Attributes

aiNode ** mChildren
The child nodes of this node.
unsigned int * | mMeshes
The meshes of this node.
aiString mName
The name of the node.
unsigned int | mNumChildren
The number of child nodes of this node.
unsigned int | mNumMeshes
The number of meshes of this node.
aiNode * mParent
Parent node.
aiMatrix4x4 mTransformation
The transformation relative to the node's parent.

Detailed Description

A node in the imported hierarchy.

Each node has name, a parent node (except for the root node), a transformation relative to its parent and possibly several child nodes. Simple file formats don't support hierarchical structures - for these formats the imported scene does consist of only a single root node without children.

Constructor & Destructor Documentation

aiNode::aiNode ( ) [inline]

Constructor.

aiNode::aiNode ( const std::string & name ) [inline]

Construction from a specific name.

aiNode::~aiNode ( ) [inline]

Destructor.

Member Function Documentation

aiNode* aiNode::FindNode ( const aiString & name ) [inline]

Searches for a node with a specific name, beginning at this nodes.

Normally you will call this method on the root node of the scene.

Parameters:
name Name to search for
Returns:
NULL or a valid Node if the search was successful.
aiNode* aiNode::FindNode ( const char * name ) [inline]

Member Data Documentation

aiNode** aiNode::mChildren

The child nodes of this node.

NULL if mNumChildren is 0.

unsigned int* aiNode::mMeshes

The meshes of this node.

Each entry is an index into the mesh

aiString aiNode::mName

The name of the node.

The name might be empty (length of zero) but all nodes which need to be accessed afterwards by bones or anims are usually named. Multiple nodes may have the same name, but nodes which are accessed by bones (see aiBone and aiMesh::mBones) *must* be unique.

Cameras and lights are assigned to a specific node name - if there are multiple nodes with this name, they're assigned to each of them.
There are no limitations regarding the characters contained in this text. You should be able to handle stuff like whitespace, tabs, linefeeds, quotation marks, ampersands, ... .

unsigned int aiNode::mNumChildren

The number of child nodes of this node.

unsigned int aiNode::mNumMeshes

The number of meshes of this node.

aiNode* aiNode::mParent

Parent node.

NULL if this node is the root node.

aiMatrix4x4 aiNode::mTransformation

The transformation relative to the node's parent.

The documentation for this struct was generated from the following file:
  • scene.h


Assimp: aiNodeAnim Struct Reference

Public Member Functions | Public Attributes
aiNodeAnim Struct Reference

Describes the animation of a single node. More...

List of all members.

Public Member Functions

aiNodeAnim ()
~aiNodeAnim ()

Public Attributes

aiString mNodeName
The name of the node affected by this animation.
unsigned int | mNumPositionKeys
The number of position keys.
unsigned int | mNumRotationKeys
The number of rotation keys.
unsigned int | mNumScalingKeys
The number of scaling keys.
aiVectorKey * mPositionKeys
The position keys of this animation channel.
aiAnimBehaviour mPostState
Defines how the animation behaves after the last key was processed.
aiAnimBehaviour mPreState
Defines how the animation behaves before the first key is encountered.
aiQuatKey * mRotationKeys
The rotation keys of this animation channel.
aiVectorKey * mScalingKeys
The scaling keys of this animation channel.

Detailed Description

Describes the animation of a single node.

The name specifies the bone/node which is affected by this animation channel. The keyframes are given in three separate series of values, one each for position, rotation and scaling. The transformation matrix computed from these values replaces the node's original transformation matrix at a specific time. This means all keys are absolute and not relative to the bone default pose. The order in which the transformations are applied is

  • as usual - scaling, rotation, translation.
Note:
All keys are returned in their correct, chronological order. Duplicate keys don't pass the validation step. Most likely there will be no negative time values, but they are not forbidden also ( so implementations need to cope with them! )

Constructor & Destructor Documentation

aiNodeAnim::aiNodeAnim ( ) [inline]
aiNodeAnim::~aiNodeAnim ( ) [inline]

Member Data Documentation

aiString aiNodeAnim::mNodeName

The name of the node affected by this animation.

The node must exist and it must be unique.

unsigned int aiNodeAnim::mNumPositionKeys

The number of position keys.

unsigned int aiNodeAnim::mNumRotationKeys

The number of rotation keys.

unsigned int aiNodeAnim::mNumScalingKeys

The number of scaling keys.

aiVectorKey* aiNodeAnim::mPositionKeys

The position keys of this animation channel.

Positions are specified as 3D vector. The array is mNumPositionKeys in size.

If there are position keys, there will also be at least one scaling and one rotation key.

aiAnimBehaviour aiNodeAnim::mPostState

Defines how the animation behaves after the last key was processed.

The default value is aiAnimBehaviour_DEFAULT (the original transformation matrix of the affected node is taken).

aiAnimBehaviour aiNodeAnim::mPreState

Defines how the animation behaves before the first key is encountered.

The default value is aiAnimBehaviour_DEFAULT (the original transformation matrix of the affected node is used).

aiQuatKey* aiNodeAnim::mRotationKeys

The rotation keys of this animation channel.

Rotations are given as quaternions, which are 4D vectors. The array is mNumRotationKeys in size.

If there are rotation keys, there will also be at least one scaling and one position key.

aiVectorKey* aiNodeAnim::mScalingKeys

The scaling keys of this animation channel.

Scalings are specified as 3D vector. The array is mNumScalingKeys in size.

If there are scaling keys, there will also be at least one position and one rotation key.

The documentation for this struct was generated from the following file:
  • anim.h


Assimp: aiPlane Struct Reference

Public Member Functions | Public Attributes
aiPlane Struct Reference

Represents a plane in a three-dimensional, euclidean space. More...

List of all members.

Public Member Functions

aiPlane ()
aiPlane (const aiPlane &o)
aiPlane (float _a, float _b, float _c, float _d)

Public Attributes

float | a
Plane equation.
float | b
float | c
float | d

Detailed Description

Represents a plane in a three-dimensional, euclidean space.

Constructor & Destructor Documentation

aiPlane::aiPlane ( ) [inline]
aiPlane::aiPlane | ( | float | _a,
 |  | float | _b,
 |  | float | _c,
 |  | float | _d
 | ) |  | [inline]
aiPlane::aiPlane ( const aiPlane & o ) [inline]

Member Data Documentation

float aiPlane::a

Plane equation.

float aiPlane::b
float aiPlane::c
float aiPlane::d
The documentation for this struct was generated from the following file:
  • types.h


Assimp: aiPropertyStore Struct Reference

Public Attributes
aiPropertyStore Struct Reference

C-API: Represents an opaque set of settings to be used during importing. More...

List of all members.

Public Attributes

char sentinel

Detailed Description

C-API: Represents an opaque set of settings to be used during importing.

See also:
aiCreatePropertyStore
aiReleasePropertyStore
aiImportFileExWithProperties
aiSetPropertyInteger
aiSetPropertyFloat
aiSetPropertyString

Member Data Documentation

char aiPropertyStore::sentinel
The documentation for this struct was generated from the following file:
  • cimport.h


Assimp: aiQuaterniont< TReal > Class Template Reference

Public Member Functions | Static Public Member Functions | Public Attributes
aiQuaterniont< TReal > Class Template Reference

Represents a quaternion in a 4D vector. More...

List of all members.

Public Member Functions

aiQuaterniont ()
aiQuaterniont (TReal w, TReal x, TReal y, TReal z)
aiQuaterniont (TReal rotx, TReal roty, TReal rotz)
Construct from euler angles.
aiQuaterniont (aiVector3t< TReal > axis, TReal angle)
Construct from an axis-angle pair.
aiQuaterniont (const aiMatrix3x3t< TReal > &pRotMatrix)
Construct from rotation matrix.
aiQuaterniont (aiVector3t< TReal > normalized)
Construct from a normalized quaternion stored in a vec3.
aiQuaterniont & Conjugate ()
Compute quaternion conjugate.
aiMatrix3x3t< TReal > | GetMatrix () const
Returns a matrix representation of the quaternion.
aiQuaterniont & Normalize ()
Normalize the quaternion.
bool | operator!= (const aiQuaterniont &o) const
aiQuaterniont | operator* (const aiQuaterniont &two) const
Multiply two quaternions.
bool | operator== (const aiQuaterniont &o) const
aiVector3t< TReal > | Rotate (const aiVector3t< TReal > &in)
Rotate a point by this quaternion.

Static Public Member Functions

static void | Interpolate (aiQuaterniont &pOut, const aiQuaterniont &pStart, const aiQuaterniont &pEnd, TReal pFactor)
Performs a spherical interpolation between two quaternions and writes the result into the third.

Public Attributes

TReal | w
w,x,y,z components of the quaternion
TReal | x
TReal | y
TReal | z

Detailed Description

template<typename TReal>
class aiQuaterniont< TReal >

Represents a quaternion in a 4D vector.

Constructor & Destructor Documentation

template<typename TReal>
aiQuaterniont< TReal >::aiQuaterniont ( ) [inline]
template<typename TReal>
aiQuaterniont< TReal >::aiQuaterniont | ( | TReal | w,
 |  | TReal | x,
 |  | TReal | y,
 |  | TReal | z
 | ) |  | [inline]
template<typename TReal>
aiQuaterniont< TReal >::aiQuaterniont ( const aiMatrix3x3t< TReal > & pRotMatrix ) [inline]

Construct from rotation matrix.

Result is undefined if the matrix is not orthonormal.

template<typename TReal>
aiQuaterniont< TReal >::aiQuaterniont | ( | TReal | rotx,
 |  | TReal | roty,
 |  | TReal | rotz
 | ) |  | [inline]

Construct from euler angles.

template<typename TReal>
aiQuaterniont< TReal >::aiQuaterniont | ( | aiVector3t< TReal > | axis,
 |  | TReal | angle
 | ) |  | [inline]

Construct from an axis-angle pair.

template<typename TReal>
aiQuaterniont< TReal >::aiQuaterniont ( aiVector3t< TReal > normalized ) [inline]

Construct from a normalized quaternion stored in a vec3.

Member Function Documentation

template<typename TReal >
aiQuaterniont< TReal > & aiQuaterniont< TReal >::Conjugate ( ) [inline]

Compute quaternion conjugate.

template<typename TReal >
aiMatrix3x3t< TReal > aiQuaterniont< TReal >::GetMatrix ( ) const [inline]

Returns a matrix representation of the quaternion.

template<typename TReal>
void aiQuaterniont< TReal >::Interpolate | ( | aiQuaterniont< TReal > & | pOut,
 |  | const aiQuaterniont< TReal > & | pStart,
 |  | const aiQuaterniont< TReal > & | pEnd,
 |  | TReal | pFactor
 | ) |  | [inline, static]

Performs a spherical interpolation between two quaternions and writes the result into the third.

Parameters:
pOut | Target object to received the interpolated rotation.
pStart | Start rotation of the interpolation at factor == 0.
pEnd | End rotation, factor == 1.
pFactor | Interpolation factor between 0 and 1. Values outside of this range yield undefined results.
template<typename TReal >
aiQuaterniont< TReal > & aiQuaterniont< TReal >::Normalize ( ) [inline]

Normalize the quaternion.

template<typename TReal >
bool aiQuaterniont< TReal >::operator!= ( const aiQuaterniont< TReal > & o ) const
template<typename TReal >
aiQuaterniont< TReal > aiQuaterniont< TReal >::operator* ( const aiQuaterniont< TReal > & two ) const [inline]

Multiply two quaternions.

template<typename TReal >
bool aiQuaterniont< TReal >::operator== ( const aiQuaterniont< TReal > & o ) const
template<typename TReal>
aiVector3t< TReal > aiQuaterniont< TReal >::Rotate ( const aiVector3t< TReal > & in ) [inline]

Rotate a point by this quaternion.

Member Data Documentation

template<typename TReal>
TReal aiQuaterniont< TReal >::w

w,x,y,z components of the quaternion

template<typename TReal>
TReal aiQuaterniont< TReal >::x
template<typename TReal>
TReal aiQuaterniont< TReal >::y
template<typename TReal>
TReal aiQuaterniont< TReal >::z
The documentation for this class was generated from the following files:
  • quaternion.h
  • quaternion.inl


Assimp: aiQuatKey Struct Reference

Public Types | Public Member Functions | Public Attributes
aiQuatKey Struct Reference

A time-value pair specifying a rotation for the given time. More...

List of all members.

Public Types

typedef aiQuaternion | elem_type

Public Member Functions

aiQuatKey ()
aiQuatKey (double time, const aiQuaternion &value)
Construction from a given time and key value.
bool | operator!= (const aiQuatKey &o) const
bool | operator< (const aiQuatKey &o) const
bool | operator== (const aiQuatKey &o) const
bool | operator> (const aiQuatKey &o) const

Public Attributes

double | mTime
The time of this key.
aiQuaternion mValue
The value of this key.

Detailed Description

A time-value pair specifying a rotation for the given time.

Rotations are expressed with quaternions.

Member Typedef Documentation

typedef aiQuaternion aiQuatKey::elem_type

Constructor & Destructor Documentation

aiQuatKey::aiQuatKey ( ) [inline]
aiQuatKey::aiQuatKey | ( | double | time,
 |  | const aiQuaternion & | value
 | ) |  | [inline]

Construction from a given time and key value.

Member Function Documentation

bool aiQuatKey::operator!= ( const aiQuatKey & o ) const [inline]
bool aiQuatKey::operator< ( const aiQuatKey & o ) const [inline]
bool aiQuatKey::operator== ( const aiQuatKey & o ) const [inline]
bool aiQuatKey::operator> ( const aiQuatKey & o ) const [inline]

Member Data Documentation

double aiQuatKey::mTime

The time of this key.

aiQuaternion aiQuatKey::mValue

The value of this key.

The documentation for this struct was generated from the following file:
  • anim.h


Assimp: aiRay Struct Reference

Public Member Functions | Public Attributes
aiRay Struct Reference

Represents a ray. More...

List of all members.

Public Member Functions

aiRay ()
aiRay (const aiRay &o)
aiRay (const aiVector3D &_pos, const aiVector3D &_dir)

Public Attributes

aiVector3D dir
aiVector3D pos
Position and direction of the ray.

Detailed Description

Represents a ray.

Constructor & Destructor Documentation

aiRay::aiRay ( ) [inline]
aiRay::aiRay | ( | const aiVector3D & | _pos,
 |  | const aiVector3D & | _dir
 | ) |  | [inline]
aiRay::aiRay ( const aiRay & o ) [inline]

Member Data Documentation

aiVector3D aiRay::dir
aiVector3D aiRay::pos

Position and direction of the ray.

The documentation for this struct was generated from the following file:
  • types.h


Assimp: aiScene Struct Reference

Public Member Functions | Public Attributes
aiScene Struct Reference

The root structure of the imported data. More...

List of all members.

Public Member Functions

aiScene ()
Default constructor - set everything to 0/NULL.
bool | HasAnimations () const
Check whether the scene contains animations.
bool | HasCameras () const
Check whether the scene contains cameras.
bool | HasLights () const
Check whether the scene contains lights.
bool | HasMaterials () const
Check whether the scene contains materials Unless no special scene flags are set this will always be true.
bool | HasMeshes () const
Check whether the scene contains meshes Unless no special scene flags are set this will always be true.
bool | HasTextures () const
Check whether the scene contains textures.
~aiScene ()
Destructor.

Public Attributes

aiAnimation ** mAnimations
The array of animations.
aiCamera ** mCameras
The array of cameras.
unsigned int | mFlags
Any combination of the AI_SCENE_FLAGS_XXX flags.
aiLight ** mLights
The array of light sources.
aiMaterial ** mMaterials
The array of materials.
aiMesh ** mMeshes
The array of meshes.
unsigned int | mNumAnimations
The number of animations in the scene.
unsigned int | mNumCameras
The number of cameras in the scene.
unsigned int | mNumLights
The number of light sources in the scene.
unsigned int | mNumMaterials
The number of materials in the scene.
unsigned int | mNumMeshes
The number of meshes in the scene.
unsigned int | mNumTextures
The number of textures embedded into the file.
void * | mPrivate
Internal data, do not touch.
aiNode * mRootNode
The root node of the hierarchy.
aiTexture ** mTextures
The array of embedded textures.

Detailed Description

The root structure of the imported data.

Everything that was imported from the given file can be accessed from here. Objects of this class are generally maintained and owned by Assimp, not by the caller. You shouldn't want to instance it, nor should you ever try to delete a given scene on your own.

Constructor & Destructor Documentation

aiScene::aiScene ( )

Default constructor - set everything to 0/NULL.

aiScene::~aiScene ( )

Destructor.

Member Function Documentation

bool aiScene::HasAnimations ( ) const [inline]

Check whether the scene contains animations.

bool aiScene::HasCameras ( ) const [inline]

Check whether the scene contains cameras.

bool aiScene::HasLights ( ) const [inline]

Check whether the scene contains lights.

bool aiScene::HasMaterials ( ) const [inline]

Check whether the scene contains materials Unless no special scene flags are set this will always be true.

bool aiScene::HasMeshes ( ) const [inline]

Check whether the scene contains meshes Unless no special scene flags are set this will always be true.

bool aiScene::HasTextures ( ) const [inline]

Check whether the scene contains textures.

Member Data Documentation

aiAnimation** aiScene::mAnimations

The array of animations.

All animations imported from the given file are listed here. The array is mNumAnimations in size.

aiCamera** aiScene::mCameras

The array of cameras.

All cameras imported from the given file are listed here. The array is mNumCameras in size. The first camera in the array (if existing) is the default camera view into the scene.

unsigned int aiScene::mFlags

Any combination of the AI_SCENE_FLAGS_XXX flags.

By default this value is 0, no flags are set. Most applications will want to reject all scenes with the AI_SCENE_FLAGS_INCOMPLETE bit set.

aiLight** aiScene::mLights

The array of light sources.

All light sources imported from the given file are listed here. The array is mNumLights in size.

aiMaterial** aiScene::mMaterials

The array of materials.

Use the index given in each aiMesh structure to access this array. The array is mNumMaterials in size. If the AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always be at least ONE material.

aiMesh** aiScene::mMeshes

The array of meshes.

Use the indices given in the aiNode structure to access this array. The array is mNumMeshes in size. If the AI_SCENE_FLAGS_INCOMPLETE flag is not set there will always be at least ONE material.

unsigned int aiScene::mNumAnimations

The number of animations in the scene.

unsigned int aiScene::mNumCameras

The number of cameras in the scene.

Cameras are fully optional, in most cases this attribute will be 0

unsigned int aiScene::mNumLights

The number of light sources in the scene.

Light sources are fully optional, in most cases this attribute will be 0

unsigned int aiScene::mNumMaterials

The number of materials in the scene.

unsigned int aiScene::mNumMeshes

The number of meshes in the scene.

unsigned int aiScene::mNumTextures

The number of textures embedded into the file.

void* aiScene::mPrivate

Internal data, do not touch.

aiNode* aiScene::mRootNode

The root node of the hierarchy.

There will always be at least the root node if the import was successful (and no special flags have been set). Presence of further nodes depends on the format and content of the imported file.

aiTexture** aiScene::mTextures

The array of embedded textures.

Not many file formats embed their textures into the file. An example is Quake's MDL format (which is also used by some GameStudio versions)

The documentation for this struct was generated from the following file:
  • scene.h


Assimp: aiString Struct Reference

Public Member Functions | Public Attributes
aiString Struct Reference

Represents an UTF-8 string, zero byte terminated. More...

List of all members.

Public Member Functions

aiString ()
Default constructor, the string is set to have zero length.
aiString (const aiString &rOther)
Copy constructor.
aiString (const std::string &pString)
Constructor from std::string.
void | Append (const char *app)
Append a string to the string.
const char * | C_Str () const
Returns a pointer to the underlying zero-terminated array of characters.
void | Clear ()
Clear the string - reset its length to zero.
bool | operator!= (const aiString &other) const
Inverse comparison operator.
aiString & | operator= (const std::string &pString)
Assign a cstd::string to the string.
aiString & | operator= (const char *sz)
Assign a const char* to the string.
bool | operator== (const aiString &other) const
Comparison operator.
void | Set (const char *sz)
Copy a const char* to the aiString.
void | Set (const std::string &pString)
Copy a std::string to the aiString.

Public Attributes

char | data [MAXLEN]
String buffer.
size_t | length
Binary length of the string excluding the terminal 0.

Detailed Description

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).

Constructor & Destructor Documentation

aiString::aiString ( ) [inline]

Default constructor, the string is set to have zero length.

aiString::aiString ( const aiString & rOther ) [inline]

Copy constructor.

aiString::aiString ( const std::string & pString ) [inline, explicit]

Constructor from std::string.

Member Function Documentation

void aiString::Append ( const char * app ) [inline]

Append a string to the string.

const char* aiString::C_Str ( ) const [inline]

Returns a pointer to the underlying zero-terminated array of characters.

void aiString::Clear ( ) [inline]

Clear the string - reset its length to zero.

bool aiString::operator!= ( const aiString & other ) const [inline]

Inverse comparison operator.

aiString& aiString::operator= ( const std::string & pString ) [inline]

Assign a cstd::string to the string.

aiString& aiString::operator= ( const char * sz ) [inline]

Assign a const char* to the string.

bool aiString::operator== ( const aiString & other ) const [inline]

Comparison operator.

void aiString::Set ( const std::string & pString ) [inline]

Copy a std::string to the aiString.

void aiString::Set ( const char * sz ) [inline]

Copy a const char* to the aiString.

Member Data Documentation

char aiString::data[MAXLEN]

String buffer.

Size limit is MAXLEN

size_t aiString::length

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.

The documentation for this struct was generated from the following file:
  • types.h


Assimp: aiTexel Struct Reference

Public Member Functions | Public Attributes
aiTexel Struct Reference

Helper structure to represent a texel in a ARGB8888 format. More...

List of all members.

Public Member Functions

operator aiColor4D () const
Conversion to a floating-point 4d color.
bool | operator!= (const aiTexel &other) const
Inverse comparison operator.
bool | operator== (const aiTexel &other) const
Comparison operator.

Public Attributes

unsigned char | a
unsigned char | b
unsigned char | g
unsigned char | r

Detailed Description

Helper structure to represent a texel in a ARGB8888 format.

Used by aiTexture.

Member Function Documentation

aiTexel::operator aiColor4D ( ) const [inline]

Conversion to a floating-point 4d color.

bool aiTexel::operator!= ( const aiTexel & other ) const [inline]

Inverse comparison operator.

bool aiTexel::operator== ( const aiTexel & other ) const [inline]

Comparison operator.

Member Data Documentation

unsigned char aiTexel::a
unsigned char aiTexel::b
unsigned char aiTexel::g
unsigned char aiTexel::r
The documentation for this struct was generated from the following file:
  • texture.h


Assimp: aiTexture Struct Reference

Public Member Functions | Public Attributes
aiTexture Struct Reference

Helper structure to describe an embedded texture. More...

List of all members.

Public Member Functions

aiTexture ()
bool | CheckFormat (const char *s) const
For compressed textures (mHeight == 0): compare the format hint against a given string.
~aiTexture ()

Public Attributes

char | achFormatHint [4]
A hint from the loader to make it easier for applications to determine the type of embedded compressed textures.
unsigned int | mHeight
Height of the texture, in pixels.
unsigned int | mWidth
Width of the texture, in pixels.
aiTexel * pcData
Data of the texture.

Detailed Description

Helper structure to describe an embedded texture.

Normally textures are contained in external files but some file formats embed them directly in the model file. There are two types of embedded textures: 1. Uncompressed textures. The color data is given in an uncompressed format. 2. Compressed textures stored in a file format like png or jpg. The raw file bytes are given so the application must utilize an image decoder (e.g. DevIL) to get access to the actual color data.

Constructor & Destructor Documentation

aiTexture::aiTexture ( ) [inline]
aiTexture::~aiTexture ( ) [inline]

Member Function Documentation

bool aiTexture::CheckFormat ( const char * s ) const [inline]

For compressed textures (mHeight == 0): compare the format hint against a given string.

Parameters:
s Input string. 3 characters are maximally processed. Example values: "jpg", "png"
Returns:
true if the given string matches the format hint

Member Data Documentation

char aiTexture::achFormatHint[4]

A hint from the loader to make it easier for applications to determine the type of embedded compressed textures.

If mHeight != 0 this member is undefined. Otherwise it is set set to '\0\0\0\0' if the loader has no additional information about the texture file format used OR the file extension of the format without a trailing dot. If there are multiple file extensions for a format, the shortest extension is chosen (JPEG maps to 'jpg', not to 'jpeg'). E.g. 'dds\0', 'pcx\0', 'jpg\0'. All characters are lower-case. The fourth character will always be '\0'.

unsigned int aiTexture::mHeight

Height of the texture, in pixels.

If this value is zero, pcData points to an compressed texture in any format (e.g. JPEG).

unsigned int aiTexture::mWidth

Width of the texture, in pixels.

If mHeight is zero the texture is compressed in a format like JPEG. In this case mWidth specifies the size of the memory area pcData is pointing to, in bytes.

aiTexel* aiTexture::pcData

Data of the texture.

Points to an array of mWidth * mHeight aiTexel's. The format of the texture data is always ARGB8888 to make the implementation for user of the library as easy as possible. If mHeight = 0 this is a pointer to a memory buffer of size mWidth containing the compressed texture data. Good luck, have fun!

The documentation for this struct was generated from the following file:
  • texture.h


Assimp: aiUVTransform Struct Reference

Public Member Functions | Public Attributes
aiUVTransform Struct Reference

Defines how an UV channel is transformed. More...

List of all members.

Public Member Functions

aiUVTransform ()

Public Attributes

float mRotation
Rotation - in counter-clockwise direction.
aiVector2D mScaling
Scaling on the u and v axes.
aiVector2D mTranslation
Translation on the u and v axes.

Detailed Description

Defines how an UV channel is transformed.

This is just a helper structure for the AI_MATKEY_UVTRANSFORM key. See its documentation for more details.

Typically you'll want to build a matrix of this information. However, we keep separate scaling/translation/rotation values to make it easier to process and optimize UV transformations internally.

Constructor & Destructor Documentation

aiUVTransform::aiUVTransform ( ) [inline]

Member Data Documentation

float aiUVTransform::mRotation

Rotation - in counter-clockwise direction.

The rotation angle is specified in radians. The rotation center is 0.5f|0.5f. The default value 0.f.

aiVector2D aiUVTransform::mScaling

Scaling on the u and v axes.

The default value is (1|1).

aiVector2D aiUVTransform::mTranslation

Translation on the u and v axes.

The default value is (0|0).

The documentation for this struct was generated from the following file:
  • material.h


Assimp: aiVector2t< TReal > Class Template Reference

Public Member Functions | Public Attributes
aiVector2t< TReal > Class Template Reference

Represents a two-dimensional vector. More...

List of all members.

Public Member Functions

aiVector2t ()
aiVector2t (TReal _x, TReal _y)
aiVector2t (const aiVector2t &o)
aiVector2t (TReal _xyz)
TReal | Length () const
aiVector2t & Normalize ()
template<typename TOther >
operator aiVector2t< TOther > () const
bool | operator!= (const aiVector2t &other) const
const aiVector2t & | operator*= (TReal f)
const aiVector2t & | operator+= (const aiVector2t &o)
const aiVector2t & | operator-= (const aiVector2t &o)
const aiVector2t & | operator/= (TReal f)
aiVector2t & | operator= (TReal f)
bool | operator== (const aiVector2t &other) const
TReal & | operator[] (unsigned int i)
TReal | operator[] (unsigned int i) const
void | Set (TReal pX, TReal pY)
TReal | SquareLength () const
const aiVector2t | SymMul (const aiVector2t &o)

Public Attributes

TReal | x
TReal | y

Detailed Description

template<typename TReal>
class aiVector2t< TReal >

Represents a two-dimensional vector.

Constructor & Destructor Documentation

template<typename TReal>
aiVector2t< TReal >::aiVector2t ( ) [inline]
template<typename TReal>
aiVector2t< TReal >::aiVector2t | ( | TReal | _x,
 |  | TReal | _y
 | ) |  | [inline]
template<typename TReal>
aiVector2t< TReal >::aiVector2t ( TReal _xyz ) [inline, explicit]
template<typename TReal>
aiVector2t< TReal >::aiVector2t ( const aiVector2t< TReal > & o ) [inline]

Member Function Documentation

template<typename TReal >
TReal aiVector2t< TReal >::Length ( ) const
template<typename TReal >
aiVector2t< TReal > & aiVector2t< TReal >::Normalize ( )
template<typename TReal >
template<typename TOther >
aiVector2t< TReal >::operator aiVector2t< TOther > ( ) const
template<typename TReal >
bool aiVector2t< TReal >::operator!= ( const aiVector2t< TReal > & other ) const
template<typename TReal>
const aiVector2t< TReal > & aiVector2t< TReal >::operator*= ( TReal f )
template<typename TReal >
const aiVector2t< TReal > & aiVector2t< TReal >::operator+= ( const aiVector2t< TReal > & o )
template<typename TReal >
const aiVector2t< TReal > & aiVector2t< TReal >::operator-= ( const aiVector2t< TReal > & o )
template<typename TReal>
const aiVector2t< TReal > & aiVector2t< TReal >::operator/= ( TReal f )
template<typename TReal>
aiVector2t< TReal > & aiVector2t< TReal >::operator= ( TReal f )
template<typename TReal >
bool aiVector2t< TReal >::operator== ( const aiVector2t< TReal > & other ) const
template<typename TReal >
TReal & aiVector2t< TReal >::operator[] ( unsigned int i )
template<typename TReal >
TReal aiVector2t< TReal >::operator[] ( unsigned int i ) const
template<typename TReal>
void aiVector2t< TReal >::Set | ( | TReal | pX,
 |  | TReal | pY
 | ) |  |
template<typename TReal >
TReal aiVector2t< TReal >::SquareLength ( ) const
template<typename TReal >
const aiVector2t< TReal > aiVector2t< TReal >::SymMul ( const aiVector2t< TReal > & o )

Member Data Documentation

template<typename TReal>
TReal aiVector2t< TReal >::x
template<typename TReal>
TReal aiVector2t< TReal >::y
The documentation for this class was generated from the following files:
  • vector2.h
  • vector2.inl


Assimp: aiVector3t< TReal > Class Template Reference

Public Member Functions | Public Attributes
aiVector3t< TReal > Class Template Reference

Represents a three-dimensional vector. More...

List of all members.

Public Member Functions

aiVector3t ()
aiVector3t (TReal _x, TReal _y, TReal _z)
aiVector3t (const aiVector3t &o)
aiVector3t (TReal _xyz)
TReal | Length () const
Get the length of the vector.
aiVector3t & Normalize ()
Normalize the vector.
template<typename TOther >
operator aiVector3t< TOther > () const
bool | operator!= (const aiVector3t &other) const
aiVector3t & | operator*= (const aiMatrix3x3t< TReal > &mat)
aiVector3t & | operator*= (const aiMatrix4x4t< TReal > &mat)
const aiVector3t & | operator*= (TReal f)
const aiVector3t & | operator+= (const aiVector3t &o)
const aiVector3t & | operator-= (const aiVector3t &o)
const aiVector3t & | operator/= (TReal f)
bool | operator== (const aiVector3t &other) const
TReal & | operator[] (unsigned int i)
TReal | operator[] (unsigned int i) const
void | Set (TReal pX, TReal pY, TReal pZ)
Set the components of a vector.
TReal | SquareLength () const
Get the squared length of the vector.
const aiVector3t | SymMul (const aiVector3t &o)
Componentwise multiplication of two vectors.

Public Attributes

TReal | x
TReal | y
TReal | z

Detailed Description

template<typename TReal>
class aiVector3t< TReal >

Represents a three-dimensional vector.

Constructor & Destructor Documentation

template<typename TReal>
aiVector3t< TReal >::aiVector3t ( ) [inline]
template<typename TReal>
aiVector3t< TReal >::aiVector3t | ( | TReal | _x,
 |  | TReal | _y,
 |  | TReal | _z
 | ) |  | [inline]
template<typename TReal>
aiVector3t< TReal >::aiVector3t ( TReal _xyz ) [inline, explicit]
template<typename TReal>
aiVector3t< TReal >::aiVector3t ( const aiVector3t< TReal > & o ) [inline]

Member Function Documentation

template<typename TReal >
AI_FORCE_INLINE TReal aiVector3t< TReal >::Length ( ) const

Get the length of the vector.

Returns:
length
template<typename TReal >
AI_FORCE_INLINE aiVector3t< TReal > & aiVector3t< TReal >::Normalize ( )

Normalize the vector.

template<typename TReal >
template<typename TOther >
aiVector3t< TReal >::operator aiVector3t< TOther > ( ) const
template<typename TReal >
AI_FORCE_INLINE bool aiVector3t< TReal >::operator!= ( const aiVector3t< TReal > & other ) const
template<typename TReal>
AI_FORCE_INLINE const aiVector3t< TReal > & aiVector3t< TReal >::operator*= ( TReal f )
template<typename TReal>
AI_FORCE_INLINE aiVector3t< TReal > & aiVector3t< TReal >::operator*= ( const aiMatrix3x3t< TReal > & mat )
template<typename TReal>
AI_FORCE_INLINE aiVector3t< TReal > & aiVector3t< TReal >::operator*= ( const aiMatrix4x4t< TReal > & mat )
template<typename TReal >
AI_FORCE_INLINE const aiVector3t< TReal > & aiVector3t< TReal >::operator+= ( const aiVector3t< TReal > & o )
template<typename TReal >
AI_FORCE_INLINE const aiVector3t< TReal > & aiVector3t< TReal >::operator-= ( const aiVector3t< TReal > & o )
template<typename TReal>
AI_FORCE_INLINE const aiVector3t< TReal > & aiVector3t< TReal >::operator/= ( TReal f )
template<typename TReal >
AI_FORCE_INLINE bool aiVector3t< TReal >::operator== ( const aiVector3t< TReal > & other ) const
template<typename TReal >
AI_FORCE_INLINE TReal & aiVector3t< TReal >::operator[] ( unsigned int i )
template<typename TReal >
AI_FORCE_INLINE TReal aiVector3t< TReal >::operator[] ( unsigned int i ) const
template<typename TReal>
AI_FORCE_INLINE void aiVector3t< TReal >::Set | ( | TReal | pX,
 |  | TReal | pY,
 |  | TReal | pZ
 | ) |  |

Set the components of a vector.

Parameters:
pX | X component
pY | Y component
pZ | Z component
template<typename TReal >
AI_FORCE_INLINE TReal aiVector3t< TReal >::SquareLength ( ) const

Get the squared length of the vector.

Returns:
Square length
template<typename TReal >
AI_FORCE_INLINE const aiVector3t< TReal > aiVector3t< TReal >::SymMul ( const aiVector3t< TReal > & o )

Componentwise multiplication of two vectors.

Note that vec*vec yields the dot product.

Parameters:
o Second factor

Member Data Documentation

template<typename TReal>
TReal aiVector3t< TReal >::x
template<typename TReal>
TReal aiVector3t< TReal >::y
template<typename TReal>
TReal aiVector3t< TReal >::z
The documentation for this class was generated from the following files:
  • vector3.h
  • vector3.inl


Assimp: aiVectorKey Struct Reference

Public Types | Public Member Functions | Public Attributes
aiVectorKey Struct Reference

A time-value pair specifying a certain 3D vector for the given time. More...

List of all members.

Public Types

typedef aiVector3D | elem_type

Public Member Functions

aiVectorKey ()
Default constructor.
aiVectorKey (double time, const aiVector3D &value)
Construction from a given time and key value.
bool | operator!= (const aiVectorKey &o) const
bool | operator< (const aiVectorKey &o) const
bool | operator== (const aiVectorKey &o) const
bool | operator> (const aiVectorKey &o) const

Public Attributes

double | mTime
The time of this key.
aiVector3D mValue
The value of this key.

Detailed Description

A time-value pair specifying a certain 3D vector for the given time.

Member Typedef Documentation

typedef aiVector3D aiVectorKey::elem_type

Constructor & Destructor Documentation

aiVectorKey::aiVectorKey ( ) [inline]

Default constructor.

aiVectorKey::aiVectorKey | ( | double | time,
 |  | const aiVector3D & | value
 | ) |  | [inline]

Construction from a given time and key value.

Member Function Documentation

bool aiVectorKey::operator!= ( const aiVectorKey & o ) const [inline]
bool aiVectorKey::operator< ( const aiVectorKey & o ) const [inline]
bool aiVectorKey::operator== ( const aiVectorKey & o ) const [inline]
bool aiVectorKey::operator> ( const aiVectorKey & o ) const [inline]

Member Data Documentation

double aiVectorKey::mTime

The time of this key.

aiVector3D aiVectorKey::mValue

The value of this key.

The documentation for this struct was generated from the following file:
  • anim.h


Assimp: aiVertexWeight Struct Reference

Public Member Functions | Public Attributes
aiVertexWeight Struct Reference

A single influence of a bone on a vertex. More...

List of all members.

Public Member Functions

aiVertexWeight ()
Default constructor.
aiVertexWeight (unsigned int pID, float pWeight)
Initialisation from a given index and vertex weight factor.

Public Attributes

unsigned int | mVertexId
Index of the vertex which is influenced by the bone.
float | mWeight
The strength of the influence in the range (0...1).

Detailed Description

A single influence of a bone on a vertex.

Constructor & Destructor Documentation

aiVertexWeight::aiVertexWeight ( ) [inline]

Default constructor.

aiVertexWeight::aiVertexWeight | ( | unsigned int | pID,
 |  | float | pWeight
 | ) |  | [inline]

Initialisation from a given index and vertex weight factor.

Parameters:
pID | ID
pWeight | Vertex weight factor

Member Data Documentation

unsigned int aiVertexWeight::mVertexId

Index of the vertex which is influenced by the bone.

float aiVertexWeight::mWeight

The strength of the influence in the range (0...1).

The influence from all bones at one vertex amounts to 1.

The documentation for this struct was generated from the following file:
  • mesh.h


Assimp: Assimp::BaseImporter Class Reference

  • Assimp
  • BaseImporter
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Friends
Assimp::BaseImporter Class Reference

FOR IMPORTER PLUGINS ONLY: The BaseImporter defines a common interface for all importer worker classes. More...

List of all members.

Public Member Functions

BaseImporter ()
Constructor to be privately used by Importer.
virtual bool | CanRead (const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const =0
Returns whether the class can handle the format of the given file.
const std::string & | GetErrorText () const
Returns the error description of the last error that occured.
void | GetExtensionList (std::set< std::string > &extensions)
Called by #Importer::GetExtensionList for each loaded importer.
virtual const aiImporterDesc * | GetInfo () const =0
Called by #Importer::GetImporterInfo to get a description of some loader features.
aiScene * | ReadFile (const Importer *pImp, const std::string &pFile, IOSystem *pIOHandler)
Imports the given file and returns the imported data.
virtual void | SetupProperties (const Importer *pImp)
Called prior to ReadFile().
virtual | ~BaseImporter ()
Destructor, private as well.

Static Public Member Functions

static bool | CheckMagicToken (IOSystem *pIOHandler, const std::string &pFile, const void *magic, unsigned int num, unsigned int offset=0, unsigned int size=4)
Check whether a file starts with one or more magic tokens.
static void | ConvertToUTF8 (std::vector< char > &data)
An utility for all text file loaders.
static std::string | GetExtension (const std::string &pFile)
Extract file extension from a string.
static bool | SearchFileHeaderForToken (IOSystem *pIOSystem, const std::string &file, const char **tokens, unsigned int numTokens, unsigned int searchBytes=200, bool tokensSol=false)
A utility for CanRead().
static bool | SimpleExtensionCheck (const std::string &pFile, const char *ext0, const char *ext1=NULL, const char *ext2=NULL)
Check whether a file has a specific file extension.
static void | TextFileToBuffer (IOStream *stream, std::vector< char > &data)
Utility for text file loaders which copies the contents of the file into a memory buffer and converts it to our UTF8 representation.

Protected Member Functions

virtual void | InternReadFile (const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler)=0
Imports the given file into the given scene structure.

Protected Attributes

std::string | mErrorText
Error description in case there was one.
ProgressHandler * progress
Currently set progress handler.

Friends

class | Importer

Detailed Description

FOR IMPORTER PLUGINS ONLY: The BaseImporter defines a common interface for all importer worker classes.

The interface defines two functions: CanRead() is used to check if the importer can handle the format of the given file. If an implementation of this function returns true, the importer then calls ReadFile() which imports the given file. ReadFile is not overridable, it just calls InternReadFile() and catches any ImportErrorException that might occur.

Constructor & Destructor Documentation

Assimp::BaseImporter::BaseImporter ( )

Constructor to be privately used by Importer.

virtual Assimp::BaseImporter::~BaseImporter ( ) [virtual]

Destructor, private as well.

Member Function Documentation

virtual bool Assimp::BaseImporter::CanRead | ( | const std::string & | pFile,
 |  | IOSystem * | pIOHandler,
 |  | bool | checkSig
 | ) |  | const [pure virtual]

Returns whether the class can handle the format of the given file.

The implementation should be as quick as possible. A check for the file extension is enough. If no suitable loader is found with this strategy, CanRead() is called again, the 'checkSig' parameter set to true this time. Now the implementation is expected to perform a full check of the file structure, possibly searching the first bytes of the file for magic identifiers or keywords.

Parameters:
pFile | Path and file name of the file to be examined.
pIOHandler | The IO handler to use for accessing any file.
checkSig | Set to true if this method is called a second time. This time, the implementation may take more time to examine the contents of the file to be loaded for magic bytes, keywords, etc to be able to load files with unknown/not existent file extensions.
Returns:
true if the class can read this file, false if not.
static bool Assimp::BaseImporter::CheckMagicToken | ( | IOSystem * | pIOHandler,
 |  | const std::string & | pFile,
 |  | const void * | magic,
 |  | unsigned int | num,
 |  | unsigned int | offset = 0,
 |  | unsigned int | size = 4
 | ) |  | [static]

Check whether a file starts with one or more magic tokens.

Parameters:
pFile | Input file
pIOHandler | IO system to be used
magic | n magic tokens num Size of magic
offset | Offset from file start where tokens are located
Size | of one token, in bytes. Maximally 16 bytes.
Returns:
true if one of the given tokens was found
Note:
For convinence, the check is also performed for the byte-swapped variant of all tokens (big endian). Only for tokens of size 2,4.
static void Assimp::BaseImporter::ConvertToUTF8 ( std::vector< char > & data ) [static]

An utility for all text file loaders.

It converts a file to our UTF8 character set. Errors are reported, but ignored.

Parameters:
data File buffer to be converted to UTF8 data. The buffer is resized as appropriate.
const std::string& Assimp::BaseImporter::GetErrorText ( ) const [inline]

Returns the error description of the last error that occured.

Returns:
A description of the last error that occured. An empty string if there was no error.
static std::string Assimp::BaseImporter::GetExtension ( const std::string & pFile ) [static]

Extract file extension from a string.

Parameters:
pFile Input file
Returns:
Extension without trailing dot, all lowercase
void Assimp::BaseImporter::GetExtensionList ( std::set< std::string > & extensions )

Called by #Importer::GetExtensionList for each loaded importer.

Take the extension list contained in the structure returned by GetInfo and insert all file extensions into the given set.

Parameters:
extension set to collect file extensions in
virtual const aiImporterDesc* Assimp::BaseImporter::GetInfo ( ) const [pure virtual]

Called by #Importer::GetImporterInfo to get a description of some loader features.

Importers must provide this information.

virtual void Assimp::BaseImporter::InternReadFile | ( | const std::string & | pFile,
 |  | aiScene * | pScene,
 |  | IOSystem * | pIOHandler
 | ) |  | [protected, pure virtual]

Imports the given file into the given scene structure.

The function is expected to throw an ImportErrorException if there is an error. If it terminates normally, the data in aiScene is expected to be correct. Override this function to implement the actual importing.
The output scene must meet the following requirements:

  • At least a root node must be there, even if its only purpose is to reference one mesh.
  • aiMesh::mPrimitiveTypes may be 0. The types of primitives in the mesh are determined automatically in this case.
  • the vertex data is stored in a pseudo-indexed "verbose" format. In fact this means that every vertex that is referenced by a face is unique. Or the other way round: a vertex index may not occur twice in a single aiMesh.
  • aiAnimation::mDuration may be -1. Assimp determines the length of the animation automatically in this case as the length of the longest animation channel.
  • aiMesh::mBitangents may be NULL if tangents and normals are given. In this case bitangents are computed as the cross product between normal and tangent.
  • There needn't be a material. If none is there a default material is generated. However, it is recommended practice for loaders to generate a default material for yourself that matches the default material setting for the file format better than Assimp's generic default material. Note that default materials *should* be named AI_DEFAULT_MATERIAL_NAME if they're just color-shaded or AI_DEFAULT_TEXTURED_MATERIAL_NAME if they define a (dummy) texture.

If the AI_SCENE_FLAGS_INCOMPLETE-Flag is not set:

  • at least one mesh must be there
  • there may be no meshes with 0 vertices or faces

This won't be checked (except by the validation step): Assimp will crash if one of the conditions is not met!

Parameters:
pFile | Path of the file to be imported.
pScene | The scene object to hold the imported data. NULL is not a valid parameter.
pIOHandler | The IO handler to use for any file access. NULL is not a valid parameter.
aiScene* Assimp::BaseImporter::ReadFile | ( | const Importer * | pImp,
 |  | const std::string & | pFile,
 |  | IOSystem * | pIOHandler
 | ) |  |

Imports the given file and returns the imported data.

If the import succeeds, ownership of the data is transferred to the caller. If the import fails, NULL is returned. The function takes care that any partially constructed data is destroyed beforehand.

Parameters:
pImp | Importer object hosting this loader.
pFile | Path of the file to be imported.
pIOHandler | IO-Handler used to open this and possible other files.
Returns:
The imported data or NULL if failed. If it failed a human-readable error description can be retrieved by calling GetErrorText()
Note:
This function is not intended to be overridden. Implement InternReadFile() to do the import. If an exception is thrown somewhere in InternReadFile(), this function will catch it and transform it into a suitable response to the caller.
static bool Assimp::BaseImporter::SearchFileHeaderForToken | ( | IOSystem * | pIOSystem,
 |  | const std::string & | file,
 |  | const char ** | tokens,
 |  | unsigned int | numTokens,
 |  | unsigned int | searchBytes = 200,
 |  | bool | tokensSol = false
 | ) |  | [static]

A utility for CanRead().

The function searches the header of a file for a specific token and returns true if this token is found. This works for text files only. There is a rudimentary handling of UNICODE files. The comparison is case independent.

Parameters:
pIOSystem | IO System to work with
file | File name of the file
tokens | List of tokens to search for
numTokens | Size of the token array
searchBytes | Number of bytes to be searched for the tokens.
virtual void Assimp::BaseImporter::SetupProperties ( const Importer * pImp ) [virtual]

Called prior to ReadFile().

The function is a request to the importer to update its configuration basing on the Importer's configuration property list.

Parameters:
pImp Importer instance
static bool Assimp::BaseImporter::SimpleExtensionCheck | ( | const std::string & | pFile,
 |  | const char * | ext0,
 |  | const char * | ext1 = NULL,
 |  | const char * | ext2 = NULL
 | ) |  | [static]

Check whether a file has a specific file extension.

Parameters:
pFile | Input file
ext0 | Extension to check for. Lowercase characters only, no dot!
ext1 | Optional second extension
ext2 | Optional third extension
Note:
Case-insensitive
static void Assimp::BaseImporter::TextFileToBuffer | ( | IOStream * | stream,
 |  | std::vector< char > & | data
 | ) |  | [static]

Utility for text file loaders which copies the contents of the file into a memory buffer and converts it to our UTF8 representation.

Parameters:
stream | Stream to read from.
data | Output buffer to be resized and filled with the converted text file data. The buffer is terminated with a binary 0.

Friends And Related Function Documentation

friend class Importer [friend]

Member Data Documentation

std::string Assimp::BaseImporter::mErrorText [protected]

Error description in case there was one.

ProgressHandler* Assimp::BaseImporter::progress [protected]

Currently set progress handler.

The documentation for this class was generated from the following file:
  • BaseImporter.h


Assimp: Assimp::DefaultLogger Class Reference

  • Assimp
  • DefaultLogger
Public Member Functions | Static Public Member Functions
Assimp::DefaultLogger Class Reference

CPP-API: Primary logging facility of Assimp. More...

Inherits Assimp::Logger.

List of all members.

Public Member Functions

bool | attachStream (LogStream *pStream, unsigned int severity)
bool | detatchStream (LogStream *pStream, unsigned int severity)

Static Public Member Functions

static Logger * | create (const char *name=ASSIMP_DEFAULT_LOG_NAME, LogSeverity severity=NORMAL, unsigned int defStreams=aiDefaultLogStream_DEBUGGER|aiDefaultLogStream_FILE, IOSystem *io=NULL)
Creates a logging instance.
static Logger * | get ()
Getter for singleton instance.
static bool | isNullLogger ()
Return whether a #NullLogger is currently active.
static void | kill ()
Kills the current singleton logger and replaces it with a #NullLogger instance.
static void | set (Logger *logger)
Setup a custom Logger implementation.

Detailed Description

CPP-API: Primary logging facility of Assimp.

The library stores its primary Logger as a static member of this class. get() returns this primary logger. By default the underlying implementation is just a #NullLogger which rejects all log messages. By calling create(), logging is turned on. To capture the log output multiple log streams (#LogStream) can be attach to the logger. Some default streams for common streaming locations (such as a file, std::cout, OutputDebugString()) are also provided.

If you wish to customize the logging at an even deeper level supply your own implementation of Logger to set().

Note:
The whole logging stuff causes a small extra overhead for all imports.

Member Function Documentation

bool Assimp::DefaultLogger::attachStream | ( | LogStream * | pStream,
 |  | unsigned int | severity
 | ) |  | [virtual]

Attach a new log-stream.

The logger takes ownership of the stream and is responsible for its destruction (which is done using ::delete when the logger itself is destroyed). Call detachStream to detach a stream and to gain ownership of it again.

Parameters:
pStream | Log-stream to attach
severity | Message filter, specified which types of log messages are dispatched to the stream. Provide a bitwise combination of the ErrorSeverity flags.
Returns:
true if the stream has been attached, false otherwise.

Implements Assimp::Logger.

static Logger* Assimp::DefaultLogger::create | ( | const char * | name = ASSIMP_DEFAULT_LOG_NAME,
 |  | LogSeverity | severity = NORMAL,
 |  | unsigned int | defStreams = aiDefaultLogStream_DEBUGGER|aiDefaultLogStream_FILE,
 |  | IOSystem * | io = NULL
 | ) |  | [static]

Creates a logging instance.

Parameters:
name | Name for log file. Only valid in combination with the aiDefaultLogStream_FILE flag.
severity | Log severity, VERBOSE turns on debug messages
defStreams | Default log streams to be attached. Any bitwise combination of the aiDefaultLogStream enumerated values. If #aiDefaultLogStream_FILE is specified but an empty string is passed for 'name', no log file is created at all.
io | IOSystem to be used to open external files (such as the log file). Pass NULL to rely on the default implementation. This replaces the default #NullLogger with a #DefaultLogger instance.
bool Assimp::DefaultLogger::detatchStream | ( | LogStream * | pStream,
 |  | unsigned int | severity
 | ) |  | [virtual]

Detach a still attached stream from the logger (or modify the filter flags bits)

Parameters:
pStream | Log-stream instance for detaching
severity | Provide a bitwise combination of the ErrorSeverity flags. This value is &~ed with the current flags of the stream, if the result is 0 the stream is detached from the Logger and the caller retakes the possession of the stream.
Returns:
true if the stream has been detached, false otherwise.

Implements Assimp::Logger.

static Logger* Assimp::DefaultLogger::get ( ) [static]

Getter for singleton instance.

Returns:
Only instance. This is never null, but it could be a NullLogger. Use isNullLogger to check this.
static bool Assimp::DefaultLogger::isNullLogger ( ) [static]

Return whether a #NullLogger is currently active.

Returns:
true if the current logger is a #NullLogger. Use create() or set() to setup a logger that does actually do something else than just rejecting all log messages.
static void Assimp::DefaultLogger::kill ( ) [static]

Kills the current singleton logger and replaces it with a #NullLogger instance.

static void Assimp::DefaultLogger::set ( Logger * logger ) [static]

Setup a custom Logger implementation.

Use this if the provided #DefaultLogger class doesn't fit into your needs. If the provided message formatting is OK for you, it's much easier to use create() and to attach your own custom output streams to it.

Parameters:
logger Pass NULL to setup a default NullLogger
The documentation for this class was generated from the following file:
  • DefaultLogger.hpp


Assimp: Assimp::Exporter Class Reference

  • Assimp
  • Exporter
Classes | Public Types | Public Member Functions | Protected Attributes
Assimp::Exporter Class Reference

CPP-API: The Exporter class forms an C++ interface to the export functionality of the Open Asset Import Library. More...

List of all members.

Classes

struct | ExportFormatEntry
Internal description of an Assimp export format option. More...

Public Types

typedef void(* | fpExportFunc )(const char *, IOSystem *, const aiScene *)
Function pointer type of a Export worker function.

Public Member Functions

aiReturn | Export (const aiScene *pScene, const char *pFormatId, const char *pPath, unsigned int pPreprocessing=0u)
Convenience function to export directly to a file.
aiReturn | Export (const aiScene *pScene, const std::string &pFormatId, const std::string &pPath, unsigned int pPreprocessing=0u)
Exporter ()
const aiExportDataBlob * | ExportToBlob (const aiScene *pScene, const char *pFormatId, unsigned int pPreprocessing=0u)
Exports the given scene to a chosen file format.
const aiExportDataBlob * | ExportToBlob (const aiScene *pScene, const std::string &pFormatId, unsigned int pPreprocessing=0u)
void | FreeBlob ()
Frees the current blob.
const aiExportDataBlob * | GetBlob () const
Return the blob obtained from the last call to ExportToBlob.
const char * | GetErrorString () const
Returns an error description of an error that occurred in Export or ExportToBlob.
size_t | GetExportFormatCount () const
Returns the number of export file formats available in the current Assimp build.
const aiExportFormatDesc * | GetExportFormatDescription (size_t pIndex) const
Returns a description of the nth export file format.
IOSystem * | GetIOHandler () const
Retrieves the IO handler that is currently set.
const aiExportDataBlob * | GetOrphanedBlob () const
Orphan the blob from the last call to ExportToBlob.
bool | IsDefaultIOHandler () const
Checks whether a default IO handler is active A default handler is active as long the application doesn't supply its own custom IO handler via SetIOHandler().
aiReturn | RegisterExporter (const ExportFormatEntry &desc)
Register a custom exporter.
void | SetIOHandler (IOSystem *pIOHandler)
Supplies a custom IO handler to the exporter to use to open and access files.
void | UnregisterExporter (const char *id)
Remove an export format previously registered with RegisterExporter from the Exporter instance (this can also be used to drop builtin exporters because those are implicitly registered using RegisterExporter).
~Exporter ()

Protected Attributes

ExporterPimpl * | pimpl

Detailed Description

CPP-API: The Exporter class forms an C++ interface to the export functionality of the Open Asset Import Library.

Note that the export interface is available only if Assimp has been built with ASSIMP_BUILD_NO_EXPORT not defined.

The interface is modelled after the importer interface and mostly symmetric. The same rules for threading etc. apply.

In a nutshell, there are two export interfaces: Export, which writes the output file(s) either to the regular file system or to a user-supplied #IOSystem, and ExportToBlob which returns a linked list of memory buffers (blob), each referring to one output file (in most cases there will be only one output file of course, but this extra complexity is needed since Assimp aims at supporting a wide range of file formats).

ExportToBlob is especially useful if you intend to work with the data in-memory.

Member Typedef Documentation

typedef void(* Assimp::Exporter::fpExportFunc)(const char *, IOSystem *, const aiScene *)

Function pointer type of a Export worker function.

Constructor & Destructor Documentation

Assimp::Exporter::Exporter ( )
Assimp::Exporter::~Exporter ( )

Member Function Documentation

aiReturn Assimp::Exporter::Export | ( | const aiScene * | pScene,
 |  | const char * | pFormatId,
 |  | const char * | pPath,
 |  | unsigned int | pPreprocessing = 0u
 | ) |  |

Convenience function to export directly to a file.

Use #SetIOSystem to supply a custom IOSystem to gain fine-grained control about the output data flow of the export process.

Parameters:
pBlob | A data blob obtained from a previous call to aiExportScene. Must not be NULL.
pPath | Full target file name. Target must be accessible.
pPreprocessing | Accepts any choice of the #aiPostProcessing enumerated 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 Assimp's default conventions as specified in the Data Structures Page . 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 the upper left. The aiProcess_MakeLeftHanded, aiProcess_FlipUVs and aiProcess_FlipWindingOrder flags are used in the import side to allow users to have those defaults automatically adapted to their conventions. Specifying those flags for exporting has the opposite effect, respectively. Some other of the 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 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 redundant as exporters would apply them anyhow. A good example is triangulation - whilst you can enforce it by specifying the aiProcess_Triangulate flag, most export formats support only triangulate data so they would run the step even if it wasn't requested.
Returns:
AI_SUCCESS if everything was fine.
aiReturn Assimp::Exporter::Export | ( | const aiScene * | pScene,
 |  | const std::string & | pFormatId,
 |  | const std::string & | pPath,
 |  | unsigned int | pPreprocessing = 0u
 | ) |  | [inline]
const aiExportDataBlob * Assimp::Exporter::ExportToBlob | ( | const aiScene * | pScene,
 |  | const std::string & | pFormatId,
 |  | unsigned int | pPreprocessing = 0u
 | ) |  | [inline]
const aiExportDataBlob* Assimp::Exporter::ExportToBlob | ( | const aiScene * | pScene,
 |  | const char * | pFormatId,
 |  | unsigned int | pPreprocessing = 0u
 | ) |  |

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. When you're done with the data, simply let the Exporter instance go out of scope to have it released automatically.

Parameters:
pScene | The scene to export. Stays in possession of the caller, is not changed by the function.
pFormatId | ID string to specify to which format you want to export to. Use GetExportFormatCount / GetExportFormatDescription to learn which export formats are available.
pPreprocessing | See the documentation for Export
Returns:
the exported data or NULL in case of error.
Note:
If the Exporter instance did already hold a blob from a previous call to ExportToBlob, it will be disposed. Any IO handlers set via SetIOHandler are ignored here.
void Assimp::Exporter::FreeBlob ( )

Frees the current blob.

The function does nothing if no blob has previously been previously produced via ExportToBlob. FreeBlob is called automatically by the destructor. The only reason to call it manually would be to reclain as much storage as possible without giving up the Exporter instance yet.

const aiExportDataBlob* Assimp::Exporter::GetBlob ( ) const

Return the blob obtained from the last call to ExportToBlob.

const char* Assimp::Exporter::GetErrorString ( ) const

Returns an error description of an error that occurred in Export or ExportToBlob.

Returns an empty string if no error occurred.

Returns:
A description of the last error, an empty string if no error occurred. The string is never NULL.
Note:
The returned function remains valid until one of the following methods is called: Export, ExportToBlob, FreeBlob
size_t Assimp::Exporter::GetExportFormatCount ( ) const

Returns the number of export file formats available in the current Assimp build.

Use #Exporter::GetExportFormatDescription to retrieve infos of a specific export format

const aiExportFormatDesc* Assimp::Exporter::GetExportFormatDescription ( size_t pIndex ) const

Returns a description of the nth export file format.

Use # #Exporter::GetExportFormatCount to learn how many export formats are supported.

Parameters:
pIndex Index of the export format to retrieve information for. Valid range is 0 to #Exporter::GetExportFormatCount
Returns:
A description of that specific export format. NULL if pIndex is out of range.
IOSystem* Assimp::Exporter::GetIOHandler ( ) const

Retrieves the IO handler that is currently set.

You can use IsDefaultIOHandler() to check whether the returned interface is the default IO handler provided by ASSIMP. The default handler is active as long the application doesn't supply its own custom IO handler via SetIOHandler().

Returns:
A valid IOSystem interface, never NULL.
const aiExportDataBlob* Assimp::Exporter::GetOrphanedBlob ( ) const

Orphan the blob from the last call to ExportToBlob.

This means the caller takes ownership and is thus responsible for calling the C API function aiReleaseExportBlob to release it.

bool Assimp::Exporter::IsDefaultIOHandler ( ) const

Checks whether a default IO handler is active A default handler is active as long the application doesn't supply its own custom IO handler via SetIOHandler().

Returns:
true by default
aiReturn Assimp::Exporter::RegisterExporter ( const ExportFormatEntry & desc )

Register a custom exporter.

Custom export formats are limited to to the current Exporter instance and do not affect the library globally.

Parameters:
desc Exporter description.
Returns:
aiReturn_SUCCESS if the export format was successfully registered. A common cause that would prevent an exporter from being registered is that its format id is already occupied by another format.
void Assimp::Exporter::SetIOHandler ( IOSystem * pIOHandler )

Supplies a custom IO handler to the exporter to use to open and access files.

If you need Export to use custom IO logic to access the files, you need to supply a custom implementation of IOSystem and IOFile to the exporter.

Exporter takes ownership of the object and will destroy it afterwards. The previously assigned handler will be deleted. Pass NULL to take again ownership of your IOSystem and reset Assimp to use its default implementation, which uses plain file IO.

Parameters:
pIOHandler The IO handler to be used in all file accesses of the Importer.
void Assimp::Exporter::UnregisterExporter ( const char * id )

Remove an export format previously registered with RegisterExporter from the Exporter instance (this can also be used to drop builtin exporters because those are implicitly registered using RegisterExporter).

Parameters:
id Format id to be unregistered, this refers to the 'id' field of aiExportFormatDesc.
Note:
Calling this method on a format description not yet registered has no effect.

Member Data Documentation

ExporterPimpl* Assimp::Exporter::pimpl [protected]
The documentation for this class was generated from the following file:
  • Exporter.hpp


Assimp: Assimp::Exporter::ExportFormatEntry Struct Reference

  • Assimp
  • Exporter
  • ExportFormatEntry
Public Member Functions | Public Attributes
Assimp::Exporter::ExportFormatEntry Struct Reference

Internal description of an Assimp export format option. More...

List of all members.

Public Member Functions

ExportFormatEntry (const char *pId, const char *pDesc, const char *pExtension, fpExportFunc pFunction, unsigned int pEnforcePP=0u)
ExportFormatEntry ()

Public Attributes

aiExportFormatDesc mDescription
Public description structure to be returned by aiGetExportFormatDescription()
unsigned int mEnforcePP
fpExportFunc mExportFunction

Detailed Description

Internal description of an Assimp export format option.

Constructor & Destructor Documentation

Assimp::Exporter::ExportFormatEntry::ExportFormatEntry | ( | const char * | pId,
 |  | const char * | pDesc,
 |  | const char * | pExtension,
 |  | fpExportFunc | pFunction,
 |  | unsigned int | pEnforcePP = 0u
 | ) |  | [inline]
Assimp::Exporter::ExportFormatEntry::ExportFormatEntry ( ) [inline]

Member Data Documentation

aiExportFormatDesc Assimp::Exporter::ExportFormatEntry::mDescription

Public description structure to be returned by aiGetExportFormatDescription()

unsigned int Assimp::Exporter::ExportFormatEntry::mEnforcePP
fpExportFunc Assimp::Exporter::ExportFormatEntry::mExportFunction
The documentation for this struct was generated from the following file:
  • Exporter.hpp


Assimp: Assimp::Importer Class Reference

  • Assimp
  • Importer
Public Member Functions | Protected Attributes
Assimp::Importer Class Reference

CPP-API: The Importer class forms an C++ interface to the functionality of the Open Asset Import Library. More...

List of all members.

Public Member Functions

const aiScene * | ApplyPostProcessing (unsigned int pFlags)
Apply post-processing to an already-imported scene.
void | FreeScene ()
Frees the current scene.
const char * | GetErrorString () const
Returns an error description of an error that occurred in ReadFile().
void | GetExtensionList (aiString &szOut) const
Get a full list of all file extensions supported by ASSIMP.
void | GetExtensionList (std::string &szOut) const
Get a full list of all file extensions supported by ASSIMP.
BaseImporter * | GetImporter (size_t index) const
Find the importer corresponding to a specific index.
BaseImporter * | GetImporter (const char *szExtension) const
Find the importer corresponding to a specific file extension.
size_t | GetImporterCount () const
Get the number of importrs currently registered with Assimp.
size_t | GetImporterIndex (const char *szExtension) const
Find the importer index corresponding to a specific file extension.
const aiImporterDesc * | GetImporterInfo (size_t index) const
Get meta data for the importer corresponding to a specific index.
IOSystem * | GetIOHandler () const
Retrieves the IO handler that is currently set.
void | GetMemoryRequirements (aiMemoryInfo &in) const
Returns the storage allocated by ASSIMP to hold the scene data in memory.
aiScene * GetOrphanedScene ()
Returns the scene loaded by the last successful call to ReadFile() and releases the scene from the ownership of the Importer instance.
ProgressHandler * | GetProgressHandler () const
Retrieves the progress handler that is currently set.
bool | GetPropertyBool (const char *szName, bool bErrorReturn=false) const
Get a boolean configuration property.
float | GetPropertyFloat (const char *szName, float fErrorReturn=10e10f) const
Get a floating-point configuration property.
int | GetPropertyInteger (const char *szName, int iErrorReturn=0xffffffff) const
Get a configuration property.
const std::string & | GetPropertyString (const char *szName, const std::string &sErrorReturn="") const
Get a string configuration property.
const aiScene * | GetScene () const
Returns the scene loaded by the last successful call to ReadFile()
Importer (const Importer &other)
Copy constructor.
Importer ()
Constructor.
bool | IsDefaultIOHandler () const
Checks whether a default IO handler is active A default handler is active as long the application doesn't supply its own custom IO handler via SetIOHandler().
bool | IsDefaultProgressHandler () const
Checks whether a default progress handler is active A default handler is active as long the application doesn't supply its own custom progress handler via SetProgressHandler().
bool | IsExtensionSupported (const std::string &szExtension) const
Returns whether a given file extension is supported by ASSIMP.
bool | IsExtensionSupported (const char *szExtension) const
Returns whether a given file extension is supported by ASSIMP.
const ImporterPimpl * | Pimpl () const
ImporterPimpl * | Pimpl ()
Private, do not use.
const aiScene * | ReadFile (const char *pFile, unsigned int pFlags)
Reads the given file and returns its contents if successful.
const aiScene * | ReadFile (const std::string &pFile, unsigned int pFlags)
Reads the given file and returns its contents if successful.
const aiScene * | ReadFileFromMemory (const void *pBuffer, size_t pLength, unsigned int pFlags, const char *pHint="")
Reads the given file from a memory buffer and returns its contents if successful.
aiReturn | RegisterLoader (BaseImporter *pImp)
Registers a new loader.
aiReturn | RegisterPPStep (BaseProcess *pImp)
Registers a new post-process step.
void | SetExtraVerbose (bool bDo)
Enables "extra verbose" mode.
void | SetIOHandler (IOSystem *pIOHandler)
Supplies a custom IO handler to the importer to use to open and access files.
void | SetProgressHandler (ProgressHandler *pHandler)
Supplies a custom progress handler to the importer.
void | SetPropertyBool (const char *szName, bool value, bool *bWasExisting=NULL)
Set a boolean configuration property.
void | SetPropertyFloat (const char *szName, float fValue, bool *bWasExisting=NULL)
Set a floating-point configuration property.
void | SetPropertyInteger (const char *szName, int iValue, bool *bWasExisting=NULL)
Set an integer configuration property.
void | SetPropertyString (const char *szName, const std::string &sValue, bool *bWasExisting=NULL)
Set a string configuration property.
aiReturn | UnregisterLoader (BaseImporter *pImp)
Unregisters a loader.
aiReturn | UnregisterPPStep (BaseProcess *pImp)
Unregisters a post-process step.
bool | ValidateFlags (unsigned int pFlags) const
Check whether a given set of postprocessing flags is supported.
~Importer ()
Destructor.

Protected Attributes

ImporterPimpl * | pimpl

Detailed Description

CPP-API: The Importer class forms an C++ interface to the functionality of the Open Asset Import Library.

Create an object of this class and call ReadFile() to import a file. If the import succeeds, the function returns a pointer to the imported data. The data remains property of the object, it is intended to be accessed read-only. The imported data will be destroyed along with the Importer object. If the import fails, ReadFile() returns a NULL pointer. In this case you can retrieve a human-readable error description be calling GetErrorString(). You can call ReadFile() multiple times with a single Importer instance. Actually, constructing Importer objects involves quite many allocations and may take some time, so it's better to reuse them as often as possible.

If you need the Importer to do custom file handling to access the files, implement IOSystem and IOStream and supply an instance of your custom IOSystem implementation by calling SetIOHandler() before calling ReadFile(). If you do not assign a custion IO handler, a default handler using the standard C++ IO logic will be used.

Note:
One Importer instance is not thread-safe. If you use multiple threads for loading, each thread should maintain its own Importer instance.

Constructor & Destructor Documentation

Assimp::Importer::Importer ( )

Constructor.

Creates an empty importer object.

Call ReadFile() to start the import process. The configuration property table is initially empty.

Assimp::Importer::Importer ( const Importer & other )

Copy constructor.

This copies the configuration properties of another Importer. If this Importer owns a scene it won't be copied. Call ReadFile() to start the import process.

Assimp::Importer::~Importer ( )

Destructor.

The object kept ownership of the imported data, which now will be destroyed along with the object.

Member Function Documentation

const aiScene* Assimp::Importer::ApplyPostProcessing ( unsigned int pFlags )

Apply post-processing to an already-imported scene.

This is strictly equivalent to calling ReadFile() with the same flags. However, you can use this separate function to inspect the imported scene first to fine-tune your post-processing setup.

Parameters:
pFlags Provide a bitwise combination of the aiPostProcessSteps flags.
Returns:
A pointer to the post-processed data. This is still the same as the pointer returned by ReadFile(). However, if post-processing fails, the scene could now be NULL. That's quite a rare case, post processing steps are not really designed to 'fail'. To be exact, the #aiProcess_ValidateDS flag is currently the only post processing step which can actually cause the scene to be reset to NULL.
Note:
The method does nothing if no scene is currently bound to the Importer instance.
void Assimp::Importer::FreeScene ( )

Frees the current scene.

The function does nothing if no scene has previously been read via ReadFile(). FreeScene() is called automatically by the destructor and ReadFile() itself.

const char* Assimp::Importer::GetErrorString ( ) const

Returns an error description of an error that occurred in ReadFile().

Returns an empty string if no error occurred.

Returns:
A description of the last error, an empty string if no error occurred. The string is never NULL.
Note:
The returned function remains valid until one of the following methods is called: ReadFile(), FreeScene().
void Assimp::Importer::GetExtensionList ( aiString & szOut ) const

Get a full list of all file extensions supported by ASSIMP.

If a file extension is contained in the list this does of course not mean that ASSIMP is able to load all files with this extension --- it simply means there is an importer loaded which claims to handle files with this file extension.

Parameters:
szOut String to receive the extension list. Format of the list: "*.3ds;*.obj;*.dae". This is useful for use with the WinAPI call GetOpenFileName(Ex).
AI_FORCE_INLINE void Assimp::Importer::GetExtensionList ( std::string & szOut ) const [inline]

Get a full list of all file extensions supported by ASSIMP.

This function is provided for backward compatibility. See the aiString version for detailed and up-to-date docs.

See also:
GetExtensionList(aiString&)
BaseImporter* Assimp::Importer::GetImporter ( size_t index ) const

Find the importer corresponding to a specific index.

Parameters:
index Index to query, must be within [0,GetImporterCount())
Returns:
Importer instance. NULL if the index does not exist.
BaseImporter* Assimp::Importer::GetImporter ( const char * szExtension ) const

Find the importer corresponding to a specific file extension.

This is quite similar to IsExtensionSupported except a BaseImporter instance is returned.

Parameters:
szExtension Extension to check for. The following formats are recognized (BAH being the file extension): "BAH" (comparison is case-insensitive), ".bah", "*.bah" (wild card and dot characters at the beginning of the extension are skipped).
Returns:
NULL if no importer is found
size_t Assimp::Importer::GetImporterCount ( ) const

Get the number of importrs currently registered with Assimp.

size_t Assimp::Importer::GetImporterIndex ( const char * szExtension ) const

Find the importer index corresponding to a specific file extension.

Parameters:
szExtension Extension to check for. The following formats are recognized (BAH being the file extension): "BAH" (comparison is case-insensitive), ".bah", "*.bah" (wild card and dot characters at the beginning of the extension are skipped).
Returns:
(size_t)-1 if no importer is found
const aiImporterDesc* Assimp::Importer::GetImporterInfo ( size_t index ) const

Get meta data for the importer corresponding to a specific index.

For the declaration of aiImporterDesc, include <assimp/importerdesc.h>.

Parameters:
index Index to query, must be within [0,GetImporterCount())
Returns:
Importer meta data structure, NULL if the index does not exist or if the importer doesn't offer meta information ( importers may do this at the cost of being hated by their peers).
IOSystem* Assimp::Importer::GetIOHandler ( ) const

Retrieves the IO handler that is currently set.

You can use IsDefaultIOHandler() to check whether the returned interface is the default IO handler provided by ASSIMP. The default handler is active as long the application doesn't supply its own custom IO handler via SetIOHandler().

Returns:
A valid IOSystem interface, never NULL.
void Assimp::Importer::GetMemoryRequirements ( aiMemoryInfo & in ) const

Returns the storage allocated by ASSIMP to hold the scene data in memory.

This refers to the currently loaded file, see ReadFile().

Parameters:
in Data structure to be filled.
Note:
The returned memory statistics refer to the actual size of the use data of the aiScene. Heap-related overhead is (naturally) not included.
aiScene* Assimp::Importer::GetOrphanedScene ( )

Returns the scene loaded by the last successful call to ReadFile() and releases the scene from the ownership of the Importer instance.

The application is now responsible for deleting the scene. Any further calls to GetScene() or GetOrphanedScene() will return NULL - until a new scene has been loaded via ReadFile().

Returns:
Current scene or NULL if there is currently no scene loaded
Note:
Use this method with maximal caution, and only if you have to. By design, aiScene's are exclusively maintained, allocated and deallocated by Assimp and no one else. The reasoning behind this is the golden rule that deallocations should always be done by the module that did the original allocation because heaps are not necessarily shared. GetOrphanedScene() enforces you to delete the returned scene by yourself, but this will only be fine if and only if you're using the same heap as assimp. On Windows, it's typically fine provided everything is linked against the multithreaded-dll version of the runtime library. It will work as well for static linkage with Assimp.
ProgressHandler* Assimp::Importer::GetProgressHandler ( ) const

Retrieves the progress handler that is currently set.

You can use IsDefaultProgressHandler() to check whether the returned interface is the default handler provided by ASSIMP. The default handler is active as long the application doesn't supply its own custom handler via SetProgressHandler().

Returns:
A valid ProgressHandler interface, never NULL.
bool Assimp::Importer::GetPropertyBool | ( | const char * | szName,
 |  | bool | bErrorReturn = false
 | ) |  | const [inline]

Get a boolean configuration property.

Boolean properties are stored on the integer stack internally so it's possible to set them via SetPropertyBool and query them with GetPropertyBool and vice versa.

See also:
GetPropertyInteger()
float Assimp::Importer::GetPropertyFloat | ( | const char * | szName,
 |  | float | fErrorReturn = 10e10f
 | ) |  | const

Get a floating-point configuration property.

See also:
GetPropertyInteger()
int Assimp::Importer::GetPropertyInteger | ( | const char * | szName,
 |  | int | iErrorReturn = 0xffffffff
 | ) |  | const

Get a configuration property.

Parameters:
szName | Name of the property. All supported properties are defined in the aiConfig.g header (all constants share the prefix AI_CONFIG_XXX).
iErrorReturn | Value that is returned if the property is not found.
Returns:
Current value of the property
Note:
Property of different types (float, int, string ..) are kept on different lists, so calling SetPropertyInteger() for a floating-point property has no effect - the loader will call GetPropertyFloat() to read the property, but it won't be there.
const std::string& Assimp::Importer::GetPropertyString | ( | const char * | szName,
 |  | const std::string & | sErrorReturn = ""
 | ) |  | const

Get a string configuration property.

The return value remains valid until the property is modified.

See also:
GetPropertyInteger()
const aiScene* Assimp::Importer::GetScene ( ) const

Returns the scene loaded by the last successful call to ReadFile()

Returns:
Current scene or NULL if there is currently no scene loaded
bool Assimp::Importer::IsDefaultIOHandler ( ) const

Checks whether a default IO handler is active A default handler is active as long the application doesn't supply its own custom IO handler via SetIOHandler().

Returns:
true by default
bool Assimp::Importer::IsDefaultProgressHandler ( ) const

Checks whether a default progress handler is active A default handler is active as long the application doesn't supply its own custom progress handler via SetProgressHandler().

Returns:
true by default
AI_FORCE_INLINE bool Assimp::Importer::IsExtensionSupported ( const std::string & szExtension ) const [inline]

Returns whether a given file extension is supported by ASSIMP.

This function is provided for backward compatibility. See the const char* version for detailed and up-to-date docs.

See also:
IsExtensionSupported(const char*)
bool Assimp::Importer::IsExtensionSupported ( const char * szExtension ) const

Returns whether a given file extension is supported by ASSIMP.

Parameters:
szExtension Extension to be checked. Must include a trailing dot '.'. Example: ".3ds", ".md3". Cases-insensitive.
Returns:
true if the extension is supported, false otherwise
ImporterPimpl* Assimp::Importer::Pimpl ( ) [inline]

Private, do not use.

const ImporterPimpl* Assimp::Importer::Pimpl ( ) const [inline]
const aiScene* Assimp::Importer::ReadFile | ( | const char * | pFile,
 |  | unsigned int | pFlags
 | ) |  |

Reads the given file and returns its contents if successful.

If the call succeeds, the contents of the file are returned as a pointer to an aiScene object. The returned data is intended to be read-only, the importer object keeps ownership of the data and will destroy it upon destruction. If the import fails, NULL is returned. A human-readable error description can be retrieved by calling GetErrorString(). The previous scene will be deleted during this call.

Parameters:
pFile | Path and filename to the file to be imported.
pFlags | Optional post processing steps to be executed after a successful import. Provide a bitwise combination of the aiPostProcessSteps flags. If you wish to inspect the imported scene first in order to fine-tune your post-processing setup, consider to use ApplyPostProcessing().
Returns:
A pointer to the imported data, NULL if the import failed. The pointer to the scene remains in possession of the Importer instance. Use GetOrphanedScene() to take ownership of it.
Note:
Assimp is able to determine the file format of a file automatically.
AI_FORCE_INLINE const aiScene * Assimp::Importer::ReadFile | ( | const std::string & | pFile,
 |  | unsigned int | pFlags
 | ) |  |

Reads the given file and returns its contents if successful.

class Importer

This function is provided for backward compatibility. See the const char* version for detailled docs.

See also:
ReadFile(const char*, pFlags)
const aiScene* Assimp::Importer::ReadFileFromMemory | ( | const void * | pBuffer,
 |  | size_t | pLength,
 |  | unsigned int | pFlags,
 |  | const char * | pHint = ""
 | ) |  |

Reads the given file from a memory buffer and returns its contents if successful.

If the call succeeds, the contents of the file are returned as a pointer to an aiScene object. The returned data is intended to be read-only, the importer object keeps ownership of the data and will destroy it upon destruction. If the import fails, NULL is returned. A human-readable error description can be retrieved by calling GetErrorString(). The previous scene will be deleted during this call. Calling this method doesn't affect the active IOSystem.

Parameters:
pBuffer | Pointer to the file data
pLength | Length of pBuffer, in bytes
pFlags | Optional post processing steps to be executed after a successful import. Provide a bitwise combination of the aiPostProcessSteps flags. If you wish to inspect the imported scene first in order to fine-tune your post-processing setup, consider to use ApplyPostProcessing().
pHint | An additional hint to the library. If this is a non empty string, the library looks for a loader to support the file extension specified by pHint and passes the file to the first matching loader. If this loader is unable to completely the request, the library continues and tries to determine the file format on its own, a task that may or may not be successful. Check the return value, and you'll know ...
Returns:
A pointer to the imported data, NULL if the import failed. The pointer to the scene remains in possession of the Importer instance. Use GetOrphanedScene() to take ownership of it.
Note:
This is a straightforward way to decode models from memory buffers, but it doesn't handle model formats spreading their data across multiple files or even directories. Examples include OBJ or MD3, which outsource parts of their material stuff into external scripts. If you need the full functionality, provide a custom IOSystem to make Assimp find these files.
aiReturn Assimp::Importer::RegisterLoader ( BaseImporter * pImp )

Registers a new loader.

Parameters:
pImp Importer to be added. The Importer instance takes ownership of the pointer, so it will be automatically deleted with the Importer instance.
Returns:
AI_SUCCESS if the loader has been added. The registration fails if there is already a loader for a specific file extension.
aiReturn Assimp::Importer::RegisterPPStep ( BaseProcess * pImp )

Registers a new post-process step.

At the moment, there's a small limitation: new post processing steps are added to end of the list, or in other words, executed last, after all built-in steps.

Parameters:
pImp Post-process step to be added. The Importer instance takes ownership of the pointer, so it will be automatically deleted with the Importer instance.
Returns:
AI_SUCCESS if the step has been added correctly.
void Assimp::Importer::SetExtraVerbose ( bool bDo )

Enables "extra verbose" mode.

'Extra verbose' means the data structure is validated after *every* single post processing step to make sure everyone modifies the data structure in a well-defined manner. This is a debug feature and not intended for use in production environments.

void Assimp::Importer::SetIOHandler ( IOSystem * pIOHandler )

Supplies a custom IO handler to the importer to use to open and access files.

If you need the importer to use custion IO logic to access the files, you need to provide a custom implementation of IOSystem and IOFile to the importer. Then create an instance of your custion IOSystem implementation and supply it by this function.

The Importer takes ownership of the object and will destroy it afterwards. The previously assigned handler will be deleted. Pass NULL to take again ownership of your IOSystem and reset Assimp to use its default implementation.

Parameters:
pIOHandler The IO handler to be used in all file accesses of the Importer.
void Assimp::Importer::SetProgressHandler ( ProgressHandler * pHandler )

Supplies a custom progress handler to the importer.

This interface exposes a #Update() callback, which is called more or less periodically (please don't sue us if it isn't as periodically as you'd like it to have ...). This can be used to implement progress bars and loading timeouts.

Parameters:
pHandler Progress callback interface. Pass NULL to disable progress reporting.
Note:
Progress handlers can be used to abort the loading at almost any time.
void Assimp::Importer::SetPropertyBool | ( | const char * | szName,
 |  | bool | value,
 |  | bool * | bWasExisting = NULL
 | ) |  | [inline]

Set a boolean configuration property.

Boolean properties are stored on the integer stack internally so it's possible to set them via SetPropertyBool and query them with GetPropertyBool and vice versa.

See also:
SetPropertyInteger()
void Assimp::Importer::SetPropertyFloat | ( | const char * | szName,
 |  | float | fValue,
 |  | bool * | bWasExisting = NULL
 | ) |  |

Set a floating-point configuration property.

See also:
SetPropertyInteger()
void Assimp::Importer::SetPropertyInteger | ( | const char * | szName,
 |  | int | iValue,
 |  | bool * | bWasExisting = NULL
 | ) |  |

Set an integer configuration property.

Parameters:
szName | Name of the property. All supported properties are defined in the aiConfig.g header (all constants share the prefix AI_CONFIG_XXX and are simple strings).
iValue | New value of the property
bWasExisting | Optional pointer to receive true if the property was set before. The new value replaces the previous value in this case.
Note:
Property of different types (float, int, string ..) are kept on different stacks, so calling SetPropertyInteger() for a floating-point property has no effect - the loader will call GetPropertyFloat() to read the property, but it won't be there.
void Assimp::Importer::SetPropertyString | ( | const char * | szName,
 |  | const std::string & | sValue,
 |  | bool * | bWasExisting = NULL
 | ) |  |

Set a string configuration property.

See also:
SetPropertyInteger()
aiReturn Assimp::Importer::UnregisterLoader ( BaseImporter * pImp )

Unregisters a loader.

Parameters:
pImp Importer to be unregistered.
Returns:
AI_SUCCESS if the loader has been removed. The function fails if the loader is currently in use (this could happen if the Importer instance is used by more than one thread) or if it has not yet been registered.
aiReturn Assimp::Importer::UnregisterPPStep ( BaseProcess * pImp )

Unregisters a post-process step.

Parameters:
pImp Step to be unregistered.
Returns:
AI_SUCCESS if the step has been removed. The function fails if the step is currently in use (this could happen if the Importer instance is used by more than one thread) or if it has not yet been registered.
bool Assimp::Importer::ValidateFlags ( unsigned int pFlags ) const

Check whether a given set of postprocessing flags is supported.

Some flags are mutually exclusive, others are probably not available because your excluded them from your Assimp builds. Calling this function is recommended if you're unsure.

Parameters:
pFlags Bitwise combination of the aiPostProcess flags.
Returns:
true if this flag combination is fine.

Member Data Documentation

ImporterPimpl* Assimp::Importer::pimpl [protected]
The documentation for this class was generated from the following file:
  • Importer.hpp


Assimp: Assimp::Interpolator< T > Struct Template Reference

  • Assimp
  • Interpolator
Public Member Functions
Assimp::Interpolator< T > Struct Template Reference

CPP-API: Utility class to simplify interpolations of various data types. More...

List of all members.

Public Member Functions

void operator() (T &out, const T &a, const T &b, float d) const
Get the result of the interpolation between a,b.

Detailed Description

template<typename T>
struct Assimp::Interpolator< T >

CPP-API: Utility class to simplify interpolations of various data types.

The type of interpolation is choosen automatically depending on the types of the arguments.

Member Function Documentation

template<typename T >
void Assimp::Interpolator< T >::operator() | ( | T & | out,
 |  | const T & | a,
 |  | const T & | b,
 |  | float | d
 | ) |  | const [inline]

Get the result of the interpolation between a,b.

The interpolation algorithm depends on the type of the operands. aiQuaternion's and aiQuatKey's SLERP, the rest does a simple linear interpolation.

The documentation for this struct was generated from the following file:
  • anim.h


Assimp: Assimp::IOStream Class Reference

  • Assimp
  • IOStream
Public Member Functions | Protected Member Functions
Assimp::IOStream Class Reference

CPP-API: Class to handle file I/O for C++. More...

List of all members.

Public Member Functions

virtual size_t | FileSize () const =0
Returns filesize Returns the filesize.
virtual void | Flush ()=0
Flush the contents of the file buffer (for writers) See fflush() for more details.
virtual size_t | Read (void *pvBuffer, size_t pSize, size_t pCount)=0
Read from the file.
virtual aiReturn | Seek (size_t pOffset, aiOrigin pOrigin)=0
Set the read/write cursor of the file.
virtual size_t | Tell () const =0
Get the current position of the read/write cursor.
virtual size_t | Write (const void *pvBuffer, size_t pSize, size_t pCount)=0
Write to the file.
virtual | ~IOStream ()
Destructor.

Protected Member Functions

IOStream (void)
Constructor protected, use IOSystem::Open() to create an instance.

Detailed Description

CPP-API: Class to handle file I/O for C++.

Derive an own implementation from this interface to provide custom IO handling to the Importer. If you implement this interface, be sure to also provide an implementation for IOSystem that creates instances of your custom IO class.

Constructor & Destructor Documentation

Assimp::IOStream::IOStream ( void ) [inline, protected]

Constructor protected, use IOSystem::Open() to create an instance.

class IOStream

Assimp::IOStream::~IOStream ( ) [inline, virtual]

Destructor.

Deleting the object closes the underlying file, alternatively you may use IOSystem::Close() to release the file.

Member Function Documentation

virtual size_t Assimp::IOStream::FileSize ( ) const [pure virtual]

Returns filesize Returns the filesize.

virtual void Assimp::IOStream::Flush ( ) [pure virtual]

Flush the contents of the file buffer (for writers) See fflush() for more details.

virtual size_t Assimp::IOStream::Read | ( | void * | pvBuffer,
 |  | size_t | pSize,
 |  | size_t | pCount
 | ) |  | [pure virtual]

Read from the file.

See fread() for more details This fails for write-only files

virtual aiReturn Assimp::IOStream::Seek | ( | size_t | pOffset,
 |  | aiOrigin | pOrigin
 | ) |  | [pure virtual]

Set the read/write cursor of the file.

Note that the offset is _negative_ for aiOrigin_END. See fseek() for more details

virtual size_t Assimp::IOStream::Tell ( ) const [pure virtual]

Get the current position of the read/write cursor.

See ftell() for more details

virtual size_t Assimp::IOStream::Write | ( | const void * | pvBuffer,
 |  | size_t | pSize,
 |  | size_t | pCount
 | ) |  | [pure virtual]

Write to the file.

See fwrite() for more details This fails for read-only files

The documentation for this class was generated from the following file:
  • IOStream.hpp


Assimp: Assimp::IOSystem Class Reference

  • Assimp
  • IOSystem
Public Member Functions
Assimp::IOSystem Class Reference

CPP-API: Interface to the file system. More...

List of all members.

Public Member Functions

virtual void | Close (IOStream *pFile)=0
Closes the given file and releases all resources associated with it.
virtual bool | ComparePaths (const char *one, const char *second) const
Compares two paths and check whether the point to identical files.
bool | ComparePaths (const std::string &one, const std::string &second) const
For backward compatibility.
virtual bool | Exists (const char *pFile) const =0
Tests for the existence of a file at the given path.
AI_FORCE_INLINE bool | Exists (const std::string &pFile) const
For backward compatibility.
virtual char | getOsSeparator () const =0
Returns the system specific directory separator.
IOSystem ()
Default constructor.
virtual IOStream * | Open (const char *pFile, const char *pMode="rb")=0
Open a new file with a given path.
IOStream * | Open (const std::string &pFile, const std::string &pMode=std::string("rb"))
For backward compatibility.
virtual | ~IOSystem ()
Virtual destructor.

Detailed Description

CPP-API: Interface to the file system.

Derive an own implementation from this interface to supply custom file handling to the importer library. If you implement this interface, you also want to supply a custom implementation for IOStream.

See also:
Importer::SetIOHandler()

Constructor & Destructor Documentation

AI_FORCE_INLINE Assimp::IOSystem::IOSystem ( )

Default constructor.

Create an instance of your derived class and assign it to an Assimp::Importer instance by calling Importer::SetIOHandler().

AI_FORCE_INLINE Assimp::IOSystem::~IOSystem ( ) [virtual]

Virtual destructor.

It is safe to be called from within DLL Assimp, we're constructed on Assimp's heap.

Member Function Documentation

virtual void Assimp::IOSystem::Close ( IOStream * pFile ) [pure virtual]

Closes the given file and releases all resources associated with it.

Parameters:
pFile The file instance previously created by Open().
bool Assimp::IOSystem::ComparePaths | ( | const std::string & | one,
 |  | const std::string & | second
 | ) |  | const [inline]

For backward compatibility.

See also:
ComparePaths(const char*, const char*)
virtual bool Assimp::IOSystem::ComparePaths | ( | const char * | one,
 |  | const char * | second
 | ) |  | const [virtual]

Compares two paths and check whether the point to identical files.

The dummy implementation of this virtual member performs a case-insensitive comparison of the given strings. The default IO system implementation uses OS mechanisms to convert relative into absolute paths, so the result can be trusted.

Parameters:
one | First file
second | Second file
Returns:
true if the paths point to the same file. The file needn't be existing, however.
virtual bool Assimp::IOSystem::Exists ( const char * pFile ) const [pure virtual]

Tests for the existence of a file at the given path.

Parameters:
pFile Path to the file
Returns:
true if there is a file with this path, else false.
AI_FORCE_INLINE bool Assimp::IOSystem::Exists ( const std::string & pFile ) const

For backward compatibility.

See also:
Exists(const char*)
virtual char Assimp::IOSystem::getOsSeparator ( ) const [pure virtual]

Returns the system specific directory separator.

Returns:
System specific directory separator
AI_FORCE_INLINE IOStream * Assimp::IOSystem::Open | ( | const std::string & | pFile,
 |  | const std::string & | pMode = std::string("rb")
 | ) |  | [inline]

For backward compatibility.

See also:
Open(const char*, const char*)
virtual IOStream* Assimp::IOSystem::Open | ( | const char * | pFile,
 |  | const char * | pMode = "rb"
 | ) |  | [pure virtual]

Open a new file with a given path.

When the access to the file is finished, call Close() to release all associated resources (or the virtual dtor of the IOStream).

Parameters:
pFile | Path to the file
pMode | Desired file I/O mode. Required are: "wb", "w", "wt", "rb", "r", "rt".
Returns:
New IOStream interface allowing the lib to access the underlying file.
Note:
When implementing this class to provide custom IO handling, you probably have to supply an own implementation of IOStream as well.
The documentation for this class was generated from the following file:
  • IOSystem.hpp


Assimp: Assimp::Logger Class Reference

  • Assimp
  • Logger
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes
Assimp::Logger Class Reference

CPP-API: Abstract interface for logger implementations. More...

Inherited by Assimp::DefaultLogger, and Assimp::NullLogger.

List of all members.

Public Types

enum | ErrorSeverity { Debugging = 1, Info = 2, Warn = 4, Err = 8 }
Description for severity of a log message. More...
enum | LogSeverity { NORMAL, VERBOSE }
Log severity to describe the granularity of logging. More...

Public Member Functions

virtual bool | attachStream (LogStream *pStream, unsigned int severity=Debugging|Err|Warn|Info)=0
Attach a new log-stream.
void | debug (const char *message)
Writes a debug message.
void | debug (const std::string &message)
virtual bool | detatchStream (LogStream *pStream, unsigned int severity=Debugging|Err|Warn|Info)=0
Detach a still attached stream from the logger (or modify the filter flags bits)
void | error (const char *message)
Writes an error message.
void | error (const std::string &message)
LogSeverity | getLogSeverity () const
Get the current log severity.
void | info (const char *message)
Writes a info message.
void | info (const std::string &message)
void | setLogSeverity (LogSeverity log_severity)
Set a new log severity.
void | warn (const std::string &message)
void | warn (const char *message)
Writes a warning message.
virtual | ~Logger ()
Virtual destructor.

Protected Member Functions

Logger ()
Default constructor.
Logger (LogSeverity severity)
Construction with a given log severity.
virtual void | OnDebug (const char *message)=0
Called as a request to write a specific debug message.
virtual void | OnError (const char *message)=0
Called as a request to write a specific error message.
virtual void | OnInfo (const char *message)=0
Called as a request to write a specific info message.
virtual void | OnWarn (const char *essage)=0
Called as a request to write a specific warn message.

Protected Attributes

LogSeverity m_Severity
Logger severity.

Detailed Description

CPP-API: Abstract interface for logger implementations.

Assimp provides a default implementation and uses it for almost all logging stuff ('DefaultLogger'). This class defines just basic logging behaviour and is not of interest for you. Instead, take a look at #DefaultLogger.

Member Enumeration Documentation

enum Assimp::Logger::ErrorSeverity

Description for severity of a log message.

Every LogStream has a bitwise combination of these flags. A LogStream doesn't receive any messages of a specific type if it doesn't specify the corresponding ErrorSeverity flag.

Enumerator:
Debugging

Debug log message.

Info

Info log message.

Warn

Warn log message.

Err

Error log message.

enum Assimp::Logger::LogSeverity

Log severity to describe the granularity of logging.

Enumerator:
NORMAL

Normal granularity of logging.

VERBOSE

Debug infos will be logged, too.

Constructor & Destructor Documentation

Assimp::Logger::~Logger ( ) [inline, virtual]

Virtual destructor.

Assimp::Logger::Logger ( ) [inline, protected]

Default constructor.

Assimp::Logger::Logger ( LogSeverity severity ) [inline, protected]

Construction with a given log severity.

Member Function Documentation

virtual bool Assimp::Logger::attachStream | ( | LogStream * | pStream,
 |  | unsigned int | severity = Debugging|Err|Warn|Info
 | ) |  | [pure virtual]

Attach a new log-stream.

The logger takes ownership of the stream and is responsible for its destruction (which is done using ::delete when the logger itself is destroyed). Call detachStream to detach a stream and to gain ownership of it again.

Parameters:
pStream | Log-stream to attach
severity | Message filter, specified which types of log messages are dispatched to the stream. Provide a bitwise combination of the ErrorSeverity flags.
Returns:
true if the stream has been attached, false otherwise.

Implemented in Assimp::DefaultLogger, and Assimp::NullLogger.

void Assimp::Logger::debug ( const char * message )

Writes a debug message.

Parameters:
message Debug message
void Assimp::Logger::debug ( const std::string & message ) [inline]
virtual bool Assimp::Logger::detatchStream | ( | LogStream * | pStream,
 |  | unsigned int | severity = Debugging|Err|Warn|Info
 | ) |  | [pure virtual]

Detach a still attached stream from the logger (or modify the filter flags bits)

Parameters:
pStream | Log-stream instance for detaching
severity | Provide a bitwise combination of the ErrorSeverity flags. This value is &~ed with the current flags of the stream, if the result is 0 the stream is detached from the Logger and the caller retakes the possession of the stream.
Returns:
true if the stream has been detached, false otherwise.

Implemented in Assimp::DefaultLogger, and Assimp::NullLogger.

void Assimp::Logger::error ( const std::string & message ) [inline]
void Assimp::Logger::error ( const char * message )

Writes an error message.

Parameters:
message Error message
Logger::LogSeverity Assimp::Logger::getLogSeverity ( ) const [inline]

Get the current log severity.

void Assimp::Logger::info ( const std::string & message ) [inline]
void Assimp::Logger::info ( const char * message )

Writes a info message.

Parameters:
message Info message
virtual void Assimp::Logger::OnDebug ( const char * message ) [protected, pure virtual]

Called as a request to write a specific debug message.

Parameters:
message Debug message. Never longer than MAX_LOG_MESSAGE_LENGTH characters (excluding the '0').
Note:
The message string is only valid until the scope of the function is left.

Implemented in Assimp::NullLogger.

virtual void Assimp::Logger::OnError ( const char * message ) [protected, pure virtual]

Called as a request to write a specific error message.

Parameters:
message Error message. Never longer than MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
Note:
The message string is only valid until the scope of the function is left.

Implemented in Assimp::NullLogger.

virtual void Assimp::Logger::OnInfo ( const char * message ) [protected, pure virtual]

Called as a request to write a specific info message.

Parameters:
message Info message. Never longer than MAX_LOG_MESSAGE_LENGTH characters (ecxluding the '0').
Note:
The message string is only valid until the scope of the function is left.

Implemented in Assimp::NullLogger.

virtual void Assimp::Logger::OnWarn ( const char * essage ) [protected, pure virtual]

Called as a request to write a specific warn message.

Parameters:
message Warn message. Never longer than MAX_LOG_MESSAGE_LENGTH characters (exluding the '0').
Note:
The message string is only valid until the scope of the function is left.

Implemented in Assimp::NullLogger.

void Assimp::Logger::setLogSeverity ( LogSeverity log_severity ) [inline]

Set a new log severity.

Parameters:
log_severity New severity for logging
void Assimp::Logger::warn ( const char * message )

Writes a warning message.

Parameters:
message Warn message
void Assimp::Logger::warn ( const std::string & message ) [inline]

Member Data Documentation

LogSeverity Assimp::Logger::m_Severity [protected]

Logger severity.

The documentation for this class was generated from the following file:
  • Logger.hpp


Assimp: Assimp::LogStream Class Reference

  • Assimp
  • LogStream
Public Member Functions | Static Public Member Functions | Protected Member Functions
Assimp::LogStream Class Reference

CPP-API: Abstract interface for log stream implementations. More...

List of all members.

Public Member Functions

virtual void | write (const char *message)=0
Overwrite this for your own output methods.
virtual | ~LogStream ()
Virtual destructor.

Static Public Member Functions

static LogStream * | createDefaultStream (aiDefaultLogStream stream, const char *name="AssimpLog.txt", IOSystem *io=NULL)
Creates a default log stream.

Protected Member Functions

LogStream ()
Default constructor.

Detailed Description

CPP-API: Abstract interface for log stream implementations.

Several default implementations are provided, see #aiDefaultLogStream for more details. Writing your own implementation of LogStream is just necessary if these are not enough for your purpose.

Constructor & Destructor Documentation

Assimp::LogStream::LogStream ( ) [inline, protected]

Default constructor.

virtual Assimp::LogStream::~LogStream ( ) [inline, virtual]

Virtual destructor.

Member Function Documentation

static LogStream* Assimp::LogStream::createDefaultStream | ( | aiDefaultLogStream | stream,
 |  | const char * | name = "AssimpLog.txt",
 |  | IOSystem * | io = NULL
 | ) |  | [static]

Creates a default log stream.

Parameters:
streams | Type of the default stream
name | For aiDefaultLogStream_FILE: name of the output file
io | For aiDefaultLogStream_FILE: IOSystem to be used to open the output file. Pass NULL for the default implementation.
Returns:
New LogStream instance.
virtual void Assimp::LogStream::write ( const char * message ) [pure virtual]

Overwrite this for your own output methods.

Log messages *may* consist of multiple lines and you shouldn't expect a consistent formatting. If you want custom formatting (e.g. generate HTML), supply a custom instance of Logger to #DefaultLogger:set(). Usually you can *expect* that a log message is exactly one line and terminated with a single
character.

Parameters:
message Message to be written
The documentation for this class was generated from the following file:
  • LogStream.hpp


Assimp: Assimp::NullLogger Class Reference

  • Assimp
  • NullLogger
Public Member Functions
Assimp::NullLogger Class Reference

CPP-API: Empty logging implementation. More...

Inherits Assimp::Logger.

List of all members.

Public Member Functions

bool | attachStream (LogStream *pStream, unsigned int severity)
Detach a still attached stream from logger.
bool | detatchStream (LogStream *pStream, unsigned int severity)
Detach a still attached stream from logger.
void | OnDebug (const char *message)
Logs a debug message.
void | OnError (const char *message)
Logs an error message.
void | OnInfo (const char *message)
Logs an info message.
void | OnWarn (const char *message)
Logs a warning message.

Detailed Description

CPP-API: Empty logging implementation.

Does nothing! Used by default if the application hasn't requested a custom logger via #DefaultLogger::set() or #DefaultLogger::create();

Member Function Documentation

bool Assimp::NullLogger::attachStream | ( | LogStream * | pStream,
 |  | unsigned int | severity
 | ) |  | [inline, virtual]

Detach a still attached stream from logger.

Implements Assimp::Logger.

bool Assimp::NullLogger::detatchStream | ( | LogStream * | pStream,
 |  | unsigned int | severity
 | ) |  | [inline, virtual]

Detach a still attached stream from logger.

Implements Assimp::Logger.

void Assimp::NullLogger::OnDebug ( const char * message ) [inline, virtual]

Logs a debug message.

Implements Assimp::Logger.

void Assimp::NullLogger::OnError ( const char * message ) [inline, virtual]

Logs an error message.

Implements Assimp::Logger.

void Assimp::NullLogger::OnInfo ( const char * message ) [inline, virtual]

Logs an info message.

Implements Assimp::Logger.

void Assimp::NullLogger::OnWarn ( const char * message ) [inline, virtual]

Logs a warning message.

Implements Assimp::Logger.

The documentation for this class was generated from the following file:
  • NullLogger.hpp


Assimp: Assimp::ProgressHandler Class Reference

  • Assimp
  • ProgressHandler
Public Member Functions | Protected Member Functions
Assimp::ProgressHandler Class Reference

CPP-API: Abstract interface for custom progress report receivers. More...

List of all members.

Public Member Functions

virtual bool | Update (float percentage=-1.f)=0
Progress callback.
virtual | ~ProgressHandler ()
Virtual destructor.

Protected Member Functions

ProgressHandler ()
Default constructor.

Detailed Description

CPP-API: Abstract interface for custom progress report receivers.

Each #Importer instance maintains its own ProgressHandler. The default implementation provided by Assimp doesn't do anything at all.

Constructor & Destructor Documentation

Assimp::ProgressHandler::ProgressHandler ( ) [inline, protected]

Default constructor.

virtual Assimp::ProgressHandler::~ProgressHandler ( ) [inline, virtual]

Virtual destructor.

Member Function Documentation

virtual bool Assimp::ProgressHandler::Update ( float percentage = -1.f ) [pure virtual]

Progress callback.

Parameters:
percentage An estimate of the current loading progress, in percent. Or -1.f if such an estimate is not available.

There are restriction on what you may do from within your implementation of this method: no exceptions may be thrown and no non-const #Importer methods may be called. It is not generally possible to predict the number of callbacks fired during a single import.

Returns:
Return false to abort loading at the next possible occasion (loaders and Assimp are generally allowed to perform all needed cleanup tasks prior to returning control to the caller). If the loading is aborted, #Importer::ReadFile() returns always NULL.
Note:
Currently, percentage is always -1.f because there is no reliable way to compute it.
The documentation for this class was generated from the following file:
  • ProgressHandler.hpp


Assimp: Assimp::ScopeGuard< T > Struct Template Reference

  • Assimp
  • ScopeGuard
Public Member Functions
Assimp::ScopeGuard< T > Struct Template Reference

List of all members.

Public Member Functions

T * | dismiss ()
operator T * ()
T * | operator-> ()
ScopeGuard (T *obj)
~ScopeGuard () throw ()

template<typename T>
struct Assimp::ScopeGuard< T >

Constructor & Destructor Documentation

template<typename T >
Assimp::ScopeGuard< T >::ScopeGuard ( T * obj ) [inline]
template<typename T >
Assimp::ScopeGuard< T >::~ScopeGuard ( ) throw () [inline]

Member Function Documentation

template<typename T >
T* Assimp::ScopeGuard< T >::dismiss ( ) [inline]
template<typename T >
Assimp::ScopeGuard< T >::operator T * ( ) [inline]
template<typename T >
T* Assimp::ScopeGuard< T >::operator-> ( ) [inline]
The documentation for this struct was generated from the following file:
  • BaseImporter.h


Assimp: Class Index

Class Index
A | B | D | E | I | L | N | P | S
A
aiImporterDesc aiPropertyStore aiVertexWeight IOStream (Assimp)
aiAnimation aiLight aiQuaterniont
B
IOSystem (Assimp)
aiAnimMesh aiLogStream aiQuatKey BaseImporter (Assimp)
L
aiBone aiMaterial aiRay
D
Logger (Assimp)
aiCamera aiMatrix3x3t aiScene DefaultLogger (Assimp) LogStream (Assimp)
aiColor3D aiMatrix4x4t aiString
E
N
aiColor4t aiMesh aiTexel Exporter (Assimp) NullLogger (Assimp)
aiExportDataBlob aiMeshAnim aiTexture Exporter::ExportFormatEntry (Assimp)
P
aiExportFormatDesc aiMeshKey aiUVTransform
I
ProgressHandler (Assimp)
aiFace aiNode aiVector2t Importer (Assimp)
S
aiFile aiNodeAnim aiVector3t Interpolator (Assimp) ScopeGuard (Assimp)
aiFileIO aiPlane aiVectorKey
A | B | D | E | I | L | N | P | S


Assimp: Class Hierarchy

Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
  • aiAnimation
  • aiAnimMesh
  • aiBone
  • aiCamera
  • aiColor3D
  • aiColor4t< TReal >
  • aiExportDataBlob
  • aiExportFormatDesc
  • aiFace
  • aiFile
  • aiFileIO
  • aiImporterDesc
  • aiLight
  • aiLogStream
  • aiMaterial
  • aiMatrix3x3t< TReal >
  • aiMatrix4x4t< TReal >
  • aiMesh
  • aiMeshAnim
  • aiMeshKey
  • aiNode
  • aiNodeAnim
  • aiPlane
  • aiPropertyStore
  • aiQuaterniont< TReal >
  • aiQuatKey
  • aiRay
  • aiScene
  • aiString
  • aiTexel
  • aiTexture
  • aiUVTransform
  • aiVector2t< TReal >
  • aiVector3t< TReal >
  • aiVectorKey
  • aiVertexWeight
  • Assimp::BaseImporter
  • Assimp::Exporter
  • Assimp::Exporter::ExportFormatEntry
  • Assimp::Importer
  • Assimp::Interpolator< T >
  • Assimp::IOStream
  • Assimp::IOSystem
  • Assimp::Logger
    • Assimp::DefaultLogger
    • Assimp::NullLogger
  • Assimp::LogStream
  • Assimp::ProgressHandler
  • Assimp::ScopeGuard< T >


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- a -

  • a : aiColor4t< TReal > , aiTexel , aiPlane
  • a1 : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • a2 : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • a3 : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • a4 : aiMatrix4x4t< TReal >
  • achFormatHint : aiTexture
  • AddBinaryProperty() : aiMaterial
  • AddProperty() : aiMaterial
  • aiAnimation() : aiAnimation
  • aiAnimMesh() : aiAnimMesh
  • aiBone() : aiBone
  • aiCamera() : aiCamera
  • aiColor3D() : aiColor3D
  • aiColor4t() : aiColor4t< TReal >
  • aiExportDataBlob() : aiExportDataBlob
  • aiFace() : aiFace
  • aiLight() : aiLight
  • aiMaterial() : aiMaterial
  • aiMatrix3x3t() : aiMatrix3x3t< TReal >
  • aiMatrix4x4t() : aiMatrix4x4t< TReal >
  • aiMesh() : aiMesh
  • aiMeshAnim() : aiMeshAnim
  • aiMeshKey() : aiMeshKey
  • aiNode() : aiNode
  • aiNodeAnim() : aiNodeAnim
  • aiPlane() : aiPlane
  • aiQuaterniont() : aiQuaterniont< TReal >
  • aiQuatKey() : aiQuatKey
  • aiRay() : aiRay
  • aiScene() : aiScene
  • aiString() : aiString
  • aiTexture() : aiTexture
  • aiUVTransform() : aiUVTransform
  • aiVector2t() : aiVector2t< TReal >
  • aiVector3t() : aiVector3t< TReal >
  • aiVectorKey() : aiVectorKey
  • aiVertexWeight() : aiVertexWeight
  • Append() : aiString
  • ApplyPostProcessing() : Assimp::Importer
  • attachStream()
: Assimp::DefaultLogger
, Assimp::NullLogger
, Assimp::Logger


Assimp: Namespace List

  • Namespace List
Namespace List
Here is a list of all namespaces with brief descriptions:
Assimp Assimp's CPP-API and all internal APIs


Assimp: Assimp Namespace Reference

  • Namespace List
Classes
Assimp Namespace Reference

Assimp's CPP-API and all internal APIs. More...

Classes

class | BaseImporter
FOR IMPORTER PLUGINS ONLY: The BaseImporter defines a common interface for all importer worker classes. More...
class | DefaultLogger
CPP-API: Primary logging facility of Assimp. More...
class | Exporter
CPP-API: The Exporter class forms an C++ interface to the export functionality of the Open Asset Import Library. More...
class | Importer
CPP-API: The Importer class forms an C++ interface to the functionality of the Open Asset Import Library. More...
struct | Interpolator
CPP-API: Utility class to simplify interpolations of various data types. More...
class | IOStream
CPP-API: Class to handle file I/O for C++. More...
class | IOSystem
CPP-API: Interface to the file system. More...
class | Logger
CPP-API: Abstract interface for logger implementations. More...
class | LogStream
CPP-API: Abstract interface for log stream implementations. More...
class | NullLogger
CPP-API: Empty logging implementation. More...
class | ProgressHandler
CPP-API: Abstract interface for custom progress report receivers. More...
struct | ScopeGuard

Detailed Description

Assimp's CPP-API and all internal APIs.


Assimp: File List

  • File List
  • File Members
File List
Here is a list of all files with brief descriptions:
ai_assert.h |
anim.h | Defines the data structures in which the imported animations are returned
BaseImporter.h |
camera.h | Defines the aiCamera data structure
cexport.h | Defines the C-API for the Assimp export interface
cfileio.h |
cimport.h |
color4.h |
color4.inl |
config.h | Defines constants for configurable properties for the library
DefaultLogger.hpp |
defs.h |
dox.h | General documentation built from a doxygen comment
Exporter.hpp |
Importer.hpp |
importerdesc.h | aiImporterFlags, aiImporterDesc implementation
IOStream.hpp |
IOSystem.hpp |
light.h | Defines the aiLight data structure
Logger.hpp | Abstract base class 'Logger', base of the logging system
LogStream.hpp |
material.h | Defines the material system of the library
material.inl |
matrix3x3.h | Definition of a 3x3 matrix, including operators when compiling in C++
matrix3x3.inl |
matrix4x4.h | 4x4 matrix structure, including operators when compiling in C++
matrix4x4.inl |
mesh.h | Declares the data structures in which the imported geometry is returned by ASSIMP: aiMesh, aiFace and aiBone data structures
NullLogger.hpp |
poppack1.h |
postprocess.h | Definitions for import post processing steps
ProgressHandler.hpp |
pushpack1.h |
quaternion.h | Quaternion structure, including operators when compiling in C++
quaternion.inl |
scene.h |
texture.h | Defines texture helper structures for the library
types.h | Basic data types and primitives, such as vectors or colors
vector2.h |
vector2.inl |
vector3.h |
vector3.inl |
version.h |


Assimp: ai_assert.h File Reference

  • File List
  • File Members
Defines
ai_assert.h File Reference

Defines

#define ai_assert(expression)

Define Documentation

#define ai_assert ( expression )


Assimp: anim.h File Reference

  • File List
  • File Members
Classes | Namespaces | Enumerations
anim.h File Reference

Defines the data structures in which the imported animations are returned. More...

Classes

struct | aiAnimation
An animation consists of keyframe data for a number of nodes. More...
struct | aiMeshAnim
Describes vertex-based animations for a single mesh or a group of meshes. More...
struct | aiMeshKey
Binds a anim mesh to a specific point in time. More...
struct | aiNodeAnim
Describes the animation of a single node. More...
struct | aiQuatKey
A time-value pair specifying a rotation for the given time. More...
struct | aiVectorKey
A time-value pair specifying a certain 3D vector for the given time. More...
struct | Assimp::Interpolator< T >
CPP-API: Utility class to simplify interpolations of various data types. More...

Namespaces

namespace | Assimp

Assimp's CPP-API and all internal APIs.

Enumerations

enum aiAnimBehaviour {
aiAnimBehaviour_DEFAULT = 0x0, aiAnimBehaviour_CONSTANT = 0x1, aiAnimBehaviour_LINEAR = 0x2, aiAnimBehaviour_REPEAT = 0x3,
_aiAnimBehaviour_Force32Bit = 0x8fffffff
}
Defines how an animation channel behaves outside the defined time range. More...

Detailed Description

Defines the data structures in which the imported animations are returned.

Enumeration Type Documentation

enum aiAnimBehaviour

Defines how an animation channel behaves outside the defined time range.

This corresponds to aiNodeAnim::mPreState and aiNodeAnim::mPostState.

Enumerator:
aiAnimBehaviour_DEFAULT

The value from the default node transformation is taken.

aiAnimBehaviour_CONSTANT

The nearest key value is used without interpolation.

aiAnimBehaviour_LINEAR

The value of the nearest two keys is linearly extrapolated for the current time value.

aiAnimBehaviour_REPEAT

The animation is repeated.

If the animation key go from n to m and the current time is t, use the value at (t-n) % (|m-n|).

_aiAnimBehaviour_Force32Bit

This value is not used, it is just here to force the the compiler to map this enum to a 32 Bit integer.


Assimp: BaseImporter.h File Reference

  • File List
  • File Members
Classes | Namespaces | Defines
BaseImporter.h File Reference

Classes

class | Assimp::BaseImporter
FOR IMPORTER PLUGINS ONLY: The BaseImporter defines a common interface for all importer worker classes. More...
struct | Assimp::ScopeGuard< T >

Namespaces

namespace | Assimp

Assimp's CPP-API and all internal APIs.

Defines

#define | AI_MAKE_MAGIC(string)

Define Documentation

#define AI_MAKE_MAGIC ( string )
Value:
((uint32_t)((string[0] << 24) + \
        (string[1] << 16) + (string[2] << 8) + string[3]))


Assimp: camera.h File Reference

  • File List
  • File Members
Classes
camera.h File Reference

Defines the aiCamera data structure. More...

Classes

struct aiCamera
Helper structure to describe a virtual camera. More...

Detailed Description

Defines the aiCamera data structure.


Assimp: cexport.h File Reference

  • File List
  • File Members
Classes | Functions
cexport.h File Reference

Defines the C-API for the Assimp export interface. More...

Classes

struct | aiExportDataBlob
Describes a blob of exported scene data. More...
struct | aiExportFormatDesc
Describes an file format which Assimp can export to. More...

Functions

ASSIMP_API void | aiCopyScene (const aiScene *pIn, aiScene **pOut)
Create a modifyable copy of a scene.
ASSIMP_API aiReturn | aiExportScene (const aiScene *pScene, const char *pFormatId, const char *pFileName, unsigned int pPreprocessing)
Exports the given scene to a chosen file format and writes the result file(s) to disk.
ASSIMP_API aiReturn | aiExportSceneEx (const aiScene *pScene, const char *pFormatId, const char *pFileName, aiFileIO *pIO, unsigned int pPreprocessing)
Exports the given scene to a chosen file format using custom IO logic supplied by you.
ASSIMP_API const aiExportDataBlob * | aiExportSceneToBlob (const aiScene *pScene, const char *pFormatId, unsigned int pPreprocessing)
Exports the given scene to a chosen file format.
ASSIMP_API size_t | aiGetExportFormatCount (void)
Returns the number of export file formats available in the current Assimp build.
ASSIMP_API const
aiExportFormatDesc * 		aiGetExportFormatDescription (size_t pIndex)
Returns a description of the nth export file format.
ASSIMP_API void | aiReleaseExportBlob (const aiExportDataBlob *pData)
Releases the memory associated with the given exported data.

Detailed Description

Defines the C-API for the Assimp export interface.

Function Documentation

ASSIMP_API void aiCopyScene | ( | const aiScene * | pIn,
 |  | aiScene ** | pOut
 | ) |  |

Create a modifyable copy of a scene.

This is useful to import files via Assimp, change their topology and export them again. Since the scene returned by the various importer functions is const, a modifyable copy is needed.

Parameters:
pIn | Valid scene to be copied
pOut | Receives a modifyable copy of the scene.
ASSIMP_API aiReturn aiExportScene | ( | const aiScene * | pScene,
 |  | const char * | pFormatId,
 |  | const char * | pFileName,
 |  | unsigned int | pPreprocessing
 | ) |  |

Exports the given scene to a chosen file format and writes the result file(s) to disk.

Parameters:
pScene | The scene to export. Stays in possession of the caller, is not changed by the function. The scene is expected to conform to Assimp's Importer output format as specified in the Data Structures Page . In short, this means the model data should use a right-handed coordinate systems, face winding should be counter-clockwise and the UV coordinate origin is assumed to be in the upper left. If your input data uses different conventions, have a look at the last parameter.
pFormatId | ID string to specify to which format you want to export to. Use aiGetExportFormatCount() / aiGetExportFormatDescription() to learn which export formats are available.
pFileName | Output file to write
pIO | custom IO implementation to be used. Use this if you use your own storage methods. If none is supplied, a default implementation using standard file IO is used. Note that aiExportSceneToBlob is provided as convenience function to export to memory buffers.
pPreprocessing | Accepts any choice of the #aiPostProcessing enumerated 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 Assimp's default conventions as specified in the Data Structures Page . 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 the upper left. The aiProcess_MakeLeftHanded, aiProcess_FlipUVs and aiProcess_FlipWindingOrder flags are used in the import side to allow users to have those defaults automatically adapted to their conventions. Specifying those flags for exporting has the opposite effect, respectively. Some other of the 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 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 redundant as exporters would apply them anyhow. A good example is triangulation - whilst you can enforce it by specifying the aiProcess_Triangulate flag, most export formats support only triangulate data so they would run the step anyway.
Returns:
a status code indicating the result of the export
ASSIMP_API aiReturn aiExportSceneEx | ( | const aiScene * | pScene,
 |  | const char * | pFormatId,
 |  | const char * | pFileName,
 |  | aiFileIO * | pIO,
 |  | unsigned int | pPreprocessing
 | ) |  |

Exports the given scene to a chosen file format using custom IO logic supplied by you.

Parameters:
pScene | The scene to export. Stays in possession of the caller, is not changed by the function.
pFormatId | ID string to specify to which format you want to export to. Use aiGetExportFormatCount() / aiGetExportFormatDescription() to learn which export formats are available.
pFileName | Output file to write
pIO | custom IO implementation to be used. Use this if you use your own storage methods. If none is supplied, a default implementation using standard file IO is used. Note that aiExportSceneToBlob is provided as convenience function to export to memory buffers.
pPreprocessing | Please see the documentation for aiExportScene
Returns:
a status code indicating the result of the export
Note:
Include <aiFileIO.h> for the definition of aiFileIO.
ASSIMP_API const aiExportDataBlob* aiExportSceneToBlob | ( | const aiScene * | pScene,
 |  | const char * | pFormatId,
 |  | unsigned int | pPreprocessing
 | ) |  |

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. When you're done with the data, use aiReleaseExportBlob() to free the resources associated with the export.

Parameters:
pScene | The scene to export. Stays in possession of the caller, is not changed by the function.
pFormatId | ID string to specify to which format you want to export to. Use aiGetExportFormatCount() / aiGetExportFormatDescription() to learn which export formats are available.
pPreprocessing | Please see the documentation for aiExportScene
Returns:
the exported data or NULL in case of error
ASSIMP_API size_t aiGetExportFormatCount ( void )

Returns the number of export file formats available in the current Assimp build.

Use aiGetExportFormatDescription() to retrieve infos of a specific export format.

ASSIMP_API const aiExportFormatDesc* aiGetExportFormatDescription ( size_t pIndex )

Returns a description of the nth export file format.

Use aiGetExportFormatCount() to learn how many export formats are supported.

Parameters:
pIndex Index of the export format to retrieve information for. Valid range is 0 to aiGetExportFormatCount()
Returns:
A description of that specific export format. NULL if pIndex is out of range.
ASSIMP_API void aiReleaseExportBlob ( const aiExportDataBlob * pData )

Releases the memory associated with the given exported data.

Use this function to free a data blob returned by aiExportScene().

Parameters:
pData the data blob returned by aiExportSceneToBlob


Assimp: cfileio.h File Reference

  • File List
  • File Members
Classes | Typedefs
cfileio.h File Reference

Classes

struct | aiFile
C-API: File callbacks. More...
struct | aiFileIO
C-API: File system callbacks. More...

Typedefs

typedef void(* | aiFileCloseProc )(aiFileIO *, aiFile *)
typedef void(* | aiFileFlushProc )(aiFile *)
typedef aiFile *(* | aiFileOpenProc )(aiFileIO *, const char *, const char *)
typedef size_t(* | aiFileReadProc )(aiFile *, char *, size_t, size_t)
typedef aiReturn(* | aiFileSeek )(aiFile *, size_t, aiOrigin)
typedef size_t(* | aiFileTellProc )(aiFile *)
typedef size_t(* | aiFileWriteProc )(aiFile *, const char *, size_t, size_t)
typedef char * | aiUserData

Typedef Documentation

typedef void(* aiFileCloseProc)(aiFileIO *, aiFile *)
typedef void(* aiFileFlushProc)(aiFile *)
typedef aiFile*(* aiFileOpenProc)(aiFileIO *, const char *, const char *)
typedef size_t(* aiFileReadProc)(aiFile *, char *, size_t, size_t)
typedef aiReturn(* aiFileSeek)(aiFile *, size_t, aiOrigin)
typedef size_t(* aiFileTellProc)(aiFile *)
typedef size_t(* aiFileWriteProc)(aiFile *, const char *, size_t, size_t)
typedef char* aiUserData


Assimp: cimport.h File Reference

  • File List
  • File Members
Classes | Defines | Typedefs | Functions
cimport.h File Reference

Classes

struct | aiLogStream
C-API: Represents a log stream. More...
struct | aiPropertyStore
C-API: Represents an opaque set of settings to be used during importing. More...

Defines

#define | AI_FALSE 0
#define | AI_TRUE 1

Typedefs

typedef int | aiBool
Our own C boolean type.
typedef void(* | aiLogStreamCallback )(const char *, char *)

Functions

ASSIMP_API const aiScene * | aiApplyPostProcessing (const aiScene *pScene, unsigned int pFlags)
Apply post-processing to an already-imported scene.
ASSIMP_API void | aiAttachLogStream (const aiLogStream *stream)
Attach a custom log stream to the libraries' logging system.
ASSIMP_API aiPropertyStore * | aiCreatePropertyStore (void)
Create an empty property store.
ASSIMP_API void | aiCreateQuaternionFromMatrix (aiQuaternion *quat, const aiMatrix3x3 *mat)
Construct a quaternion from a 3x3 rotation matrix.
ASSIMP_API void | aiDecomposeMatrix (const aiMatrix4x4 *mat, aiVector3D *scaling, aiQuaternion *rotation, aiVector3D *position)
Decompose a transformation matrix into its rotational, translational and scaling components.
ASSIMP_API void | aiDetachAllLogStreams (void)
Detach all active log streams from the libraries' logging system.
ASSIMP_API aiReturn | aiDetachLogStream (const aiLogStream *stream)
Detach a custom log stream from the libraries' logging system.
ASSIMP_API void | aiEnableVerboseLogging (aiBool d)
Enable verbose logging.
ASSIMP_API const char * | aiGetErrorString ()
Returns the error text of the last failed import process.
ASSIMP_API void | aiGetExtensionList (aiString *szOut)
Get a list of all file extensions supported by ASSIMP.
ASSIMP_API void | aiGetMemoryRequirements (const aiScene *pIn, aiMemoryInfo *in)
Get the approximated storage required by an imported asset.
ASSIMP_API aiLogStream | aiGetPredefinedLogStream (aiDefaultLogStream pStreams, const char *file)
Get one of the predefine log streams.
ASSIMP_API void | aiIdentityMatrix3 (aiMatrix3x3 *mat)
Get a 3x3 identity matrix.
ASSIMP_API void | aiIdentityMatrix4 (aiMatrix4x4 *mat)
Get a 4x4 identity matrix.
ASSIMP_API const aiScene * | aiImportFile (const char *pFile, unsigned int pFlags)
Reads the given file and returns its content.
ASSIMP_API const aiScene * | aiImportFileEx (const char *pFile, unsigned int pFlags, aiFileIO *pFS)
Reads the given file using user-defined I/O functions and returns its content.
ASSIMP_API const aiScene * | aiImportFileExWithProperties (const char *pFile, unsigned int pFlags, aiFileIO *pFS, const aiPropertyStore *pProps)
Same as aiImportFileEx, but adds an extra parameter containing importer settings.
ASSIMP_API const aiScene * | aiImportFileFromMemory (const char *pBuffer, unsigned int pLength, unsigned int pFlags, const char *pHint)
Reads the given file from a given memory buffer,.
ASSIMP_API const aiScene * | aiImportFileFromMemoryWithProperties (const char *pBuffer, unsigned int pLength, unsigned int pFlags, const char *pHint, const aiPropertyStore *pProps)
Same as aiImportFileFromMemory, but adds an extra parameter containing importer settings.
ASSIMP_API aiBool | aiIsExtensionSupported (const char *szExtension)
Returns whether a given file extension is supported by ASSIMP.
ASSIMP_API void | aiMultiplyMatrix3 (aiMatrix3x3 *dst, const aiMatrix3x3 *src)
Multiply two 3x3 matrices.
ASSIMP_API void | aiMultiplyMatrix4 (aiMatrix4x4 *dst, const aiMatrix4x4 *src)
Multiply two 4x4 matrices.
ASSIMP_API void | aiReleaseImport (const aiScene *pScene)
Releases all resources associated with the given import process.
ASSIMP_API void | aiReleasePropertyStore (aiPropertyStore *p)
Delete a property store.
ASSIMP_API void | aiSetImportPropertyFloat (aiPropertyStore *store, const char *szName, float value)
Set a floating-point property.
ASSIMP_API void | aiSetImportPropertyInteger (aiPropertyStore *store, const char *szName, int value)
Set an integer property.
ASSIMP_API void | aiSetImportPropertyString (aiPropertyStore *store, const char *szName, const aiString *st)
Set a string property.
ASSIMP_API void | aiTransformVecByMatrix3 (aiVector3D *vec, const aiMatrix3x3 *mat)
Transform a vector by a 3x3 matrix.
ASSIMP_API void | aiTransformVecByMatrix4 (aiVector3D *vec, const aiMatrix4x4 *mat)
Transform a vector by a 4x4 matrix.
ASSIMP_API void | aiTransposeMatrix3 (aiMatrix3x3 *mat)
Transpose a 3x3 matrix.
ASSIMP_API void | aiTransposeMatrix4 (aiMatrix4x4 *mat)
Transpose a 4x4 matrix.

Define Documentation

#define AI_FALSE 0
#define AI_TRUE 1

Typedef Documentation

typedef int aiBool

Our own C boolean type.

typedef void(* aiLogStreamCallback)(const char *, char *)

Function Documentation

ASSIMP_API const aiScene* aiApplyPostProcessing | ( | const aiScene * | pScene,
 |  | unsigned int | pFlags
 | ) |  |

Apply post-processing to an already-imported scene.

This is strictly equivalent to calling aiImportFile()/aiImportFileEx with the same flags. However, you can use this separate function to inspect the imported scene first to fine-tune your post-processing setup.

Parameters:
pScene | Scene to work on.
pFlags | Provide a bitwise combination of the aiPostProcessSteps flags.
Returns:
A pointer to the post-processed data. Post processing is done in-place, meaning this is still the same aiScene which you passed for pScene. However, _if_ post-processing failed, the scene could now be NULL. That's quite a rare case, post processing steps are not really designed to 'fail'. To be exact, the #aiProcess_ValidateDS flag is currently the only post processing step which can actually cause the scene to be reset to NULL.
ASSIMP_API void aiAttachLogStream ( const aiLogStream * stream )

Attach a custom log stream to the libraries' logging system.

Attaching a log stream can slightly reduce Assimp's overall import performance. Multiple log-streams can be attached.

Parameters:
stream Describes the new log stream.
Note:
To ensure proepr destruction of the logging system, you need to manually call aiDetachLogStream() on every single log stream you attach. Alternatively (for the lazy folks) aiDetachAllLogStreams is provided.
ASSIMP_API aiPropertyStore* aiCreatePropertyStore ( void )

Create an empty property store.

Property stores are used to collect import settings.

Returns:
New property store. Property stores need to be manually destroyed using the aiReleasePropertyStore API function.
ASSIMP_API void aiCreateQuaternionFromMatrix | ( | aiQuaternion * | quat,
 |  | const aiMatrix3x3 * | mat
 | ) |  |

Construct a quaternion from a 3x3 rotation matrix.

Parameters:
quat | Receives the output quaternion.
mat | Matrix to 'quaternionize'.
See also:
aiQuaternion(const aiMatrix3x3& pRotMatrix)
ASSIMP_API void aiDecomposeMatrix | ( | const aiMatrix4x4 * | mat,
 |  | aiVector3D * | scaling,
 |  | aiQuaternion * | rotation,
 |  | aiVector3D * | position
 | ) |  |

Decompose a transformation matrix into its rotational, translational and scaling components.

Parameters:
mat | Matrix to decompose
scaling | Receives the scaling component
rotation | Receives the rotational component
position | Receives the translational component.
See also:
aiMatrix4x4::Decompose (aiVector3D&, aiQuaternion&, aiVector3D&) const;
ASSIMP_API void aiDetachAllLogStreams ( void )

Detach all active log streams from the libraries' logging system.

This ensures that the logging system is terminated properly and all resources allocated by it are actually freed. If you attached a stream, don't forget to detach it again.

See also:
aiAttachLogStream
aiDetachLogStream
ASSIMP_API aiReturn aiDetachLogStream ( const aiLogStream * stream )

Detach a custom log stream from the libraries' logging system.

This is the counterpart of #aiAttachPredefinedLogStream. If you attached a stream, don't forget to detach it again.

Parameters:
stream The log stream to be detached.
Returns:
AI_SUCCESS if the log stream has been detached successfully.
See also:
aiDetachAllLogStreams
ASSIMP_API void aiEnableVerboseLogging ( aiBool d )

Enable verbose logging.

Verbose logging includes debug-related stuff and detailed import statistics. This can have severe impact on import performance and memory consumption. However, it might be useful to find out why a file didn't read correctly.

Parameters:
d AI_TRUE or AI_FALSE, your decision.
ASSIMP_API const char* aiGetErrorString ( )

Returns the error text of the last failed import process.

Returns:
A textual description of the error that occurred at the last import process. NULL if there was no error. There can't be an error if you got a non-NULL aiScene from aiImportFile/aiImportFileEx/aiApplyPostProcessing.
ASSIMP_API void aiGetExtensionList ( aiString * szOut )

Get a list of all file extensions supported by ASSIMP.

If a file extension is contained in the list this does, of course, not mean that ASSIMP is able to load all files with this extension.

Parameters:
szOut String to receive the extension list. Format of the list: "*.3ds;*.obj;*.dae". NULL is not a valid parameter.
ASSIMP_API void aiGetMemoryRequirements | ( | const aiScene * | pIn,
 |  | aiMemoryInfo * | in
 | ) |  |

Get the approximated storage required by an imported asset.

Parameters:
pIn | Input asset.
in | Data structure to be filled.
ASSIMP_API aiLogStream aiGetPredefinedLogStream | ( | aiDefaultLogStream | pStreams,
 |  | const char * | file
 | ) |  |

Get one of the predefine log streams.

This is the quick'n'easy solution to access Assimp's log system. Attaching a log stream can slightly reduce Assimp's overall import performance.

Usage is rather simple (this will stream the log to a file, named log.txt, and the stdout stream of the process:

    struct aiLogStream c;
    c = aiGetPredefinedLogStream(aiDefaultLogStream_FILE,"log.txt");
    aiAttachLogStream(&c);
    c = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT,NULL);
    aiAttachLogStream(&c);
Parameters:
pStreams | One of the #aiDefaultLogStream enumerated values.
file | Solely for the #aiDefaultLogStream_FILE flag: specifies the file to write to. Pass NULL for all other flags.
Returns:
The log stream. callback is set to NULL if something went wrong.
ASSIMP_API void aiIdentityMatrix3 ( aiMatrix3x3 * mat )

Get a 3x3 identity matrix.

Parameters:
mat Matrix to receive its personal identity
ASSIMP_API void aiIdentityMatrix4 ( aiMatrix4x4 * mat )

Get a 4x4 identity matrix.

Parameters:
mat Matrix to receive its personal identity
ASSIMP_API const aiScene* aiImportFile | ( | const char * | pFile,
 |  | unsigned int | pFlags
 | ) |  |

Reads the given file and returns its content.

If the call succeeds, the imported data is returned in an aiScene structure. The data is intended to be read-only, it stays property of the ASSIMP library and will be stable until aiReleaseImport() is called. After you're done with it, call aiReleaseImport() to free the resources associated with this file. If the import fails, NULL is returned instead. Call aiGetErrorString() to retrieve a human-readable error text.

Parameters:
pFile | Path and filename of the file to be imported, expected to be a null-terminated c-string. NULL is not a valid value.
pFlags | Optional post processing steps to be executed after a successful import. Provide a bitwise combination of the aiPostProcessSteps flags.
Returns:
Pointer to the imported data or NULL if the import failed.
ASSIMP_API const aiScene* aiImportFileEx | ( | const char * | pFile,
 |  | unsigned int | pFlags,
 |  | aiFileIO * | pFS
 | ) |  |

Reads the given file using user-defined I/O functions and returns its content.

If the call succeeds, the imported data is returned in an aiScene structure. The data is intended to be read-only, it stays property of the ASSIMP library and will be stable until aiReleaseImport() is called. After you're done with it, call aiReleaseImport() to free the resources associated with this file. If the import fails, NULL is returned instead. Call aiGetErrorString() to retrieve a human-readable error text.

Parameters:
pFile | Path and filename of the file to be imported, expected to be a null-terminated c-string. NULL is not a valid value.
pFlags | Optional post processing steps to be executed after a successful import. Provide a bitwise combination of the aiPostProcessSteps flags.
pFS | aiFileIO structure. Will be used to open the model file itself and any other files the loader needs to open. Pass NULL to use the default implementation.
Returns:
Pointer to the imported data or NULL if the import failed.
Note:
Include <aiFileIO.h> for the definition of aiFileIO.
ASSIMP_API const aiScene* aiImportFileExWithProperties | ( | const char * | pFile,
 |  | unsigned int | pFlags,
 |  | aiFileIO * | pFS,
 |  | const aiPropertyStore * | pProps
 | ) |  |

Same as aiImportFileEx, but adds an extra parameter containing importer settings.

Parameters:
pProps aiPropertyStore instance containing import settings.
See also:
aiImportFileEx
ASSIMP_API const aiScene* aiImportFileFromMemory | ( | const char * | pBuffer,
 |  | unsigned int | pLength,
 |  | unsigned int | pFlags,
 |  | const char * | pHint
 | ) |  |

Reads the given file from a given memory buffer,.

If the call succeeds, the contents of the file are returned as a pointer to an aiScene object. The returned data is intended to be read-only, the importer keeps ownership of the data and will destroy it upon destruction. If the import fails, NULL is returned. A human-readable error description can be retrieved by calling aiGetErrorString().

Parameters:
pBuffer | Pointer to the file data
pLength | Length of pBuffer, in bytes
pFlags | Optional post processing steps to be executed after a successful import. Provide a bitwise combination of the aiPostProcessSteps flags. If you wish to inspect the imported scene first in order to fine-tune your post-processing setup, consider to use aiApplyPostProcessing().
pHint | An additional hint to the library. If this is a non empty string, the library looks for a loader to support the file extension specified by pHint and passes the file to the first matching loader. If this loader is unable to completely the request, the library continues and tries to determine the file format on its own, a task that may or may not be successful. Check the return value, and you'll know ...
Returns:
A pointer to the imported data, NULL if the import failed.
Note:
This is a straightforward way to decode models from memory buffers, but it doesn't handle model formats spreading their data across multiple files or even directories. Examples include OBJ or MD3, which outsource parts of their material stuff into external scripts. If you need the full functionality, provide a custom IOSystem to make Assimp find these files.
ASSIMP_API const aiScene* aiImportFileFromMemoryWithProperties | ( | const char * | pBuffer,
 |  | unsigned int | pLength,
 |  | unsigned int | pFlags,
 |  | const char * | pHint,
 |  | const aiPropertyStore * | pProps
 | ) |  |

Same as aiImportFileFromMemory, but adds an extra parameter containing importer settings.

Parameters:
pProps aiPropertyStore instance containing import settings.
See also:
aiImportFileFromMemory
ASSIMP_API aiBool aiIsExtensionSupported ( const char * szExtension )

Returns whether a given file extension is supported by ASSIMP.

Parameters:
szExtension Extension for which the function queries support for. Must include a leading dot '.'. Example: ".3ds", ".md3"
Returns:
AI_TRUE if the file extension is supported.
ASSIMP_API void aiMultiplyMatrix3 | ( | aiMatrix3x3 * | dst,
 |  | const aiMatrix3x3 * | src
 | ) |  |

Multiply two 3x3 matrices.

Parameters:
dst | First factor, receives result.
src | Matrix to be multiplied with 'dst'.
ASSIMP_API void aiMultiplyMatrix4 | ( | aiMatrix4x4 * | dst,
 |  | const aiMatrix4x4 * | src
 | ) |  |

Multiply two 4x4 matrices.

Parameters:
dst | First factor, receives result.
src | Matrix to be multiplied with 'dst'.
ASSIMP_API void aiReleaseImport ( const aiScene * pScene )

Releases all resources associated with the given import process.

Call this function after you're done with the imported data.

Parameters:
pScene The imported data to release. NULL is a valid value.
ASSIMP_API void aiReleasePropertyStore ( aiPropertyStore * p )

Delete a property store.

Parameters:
p Property store to be deleted.
ASSIMP_API void aiSetImportPropertyFloat | ( | aiPropertyStore * | store,
 |  | const char * | szName,
 |  | float | value
 | ) |  |

Set a floating-point property.

This is the C-version of Assimp::Importer::SetPropertyFloat(). In the C interface, properties are always shared by all imports. It is not possible to specify them per import.

Parameters:
szName | Name of the configuration property to be set. All supported public properties are defined in the config.h header file (#AI_CONFIG_XXX).
value | New value for the property
ASSIMP_API void aiSetImportPropertyInteger | ( | aiPropertyStore * | store,
 |  | const char * | szName,
 |  | int | value
 | ) |  |

Set an integer property.

This is the C-version of Assimp::Importer::SetPropertyInteger(). In the C interface, properties are always shared by all imports. It is not possible to specify them per import.

Parameters:
szName | Name of the configuration property to be set. All supported public properties are defined in the config.h header file (#AI_CONFIG_XXX).
value | New value for the property
ASSIMP_API void aiSetImportPropertyString | ( | aiPropertyStore * | store,
 |  | const char * | szName,
 |  | const aiString * | st
 | ) |  |

Set a string property.

This is the C-version of Assimp::Importer::SetPropertyString(). In the C interface, properties are always shared by all imports. It is not possible to specify them per import.

Parameters:
property | store to modify. Use aiCreatePropertyStore to obtain a store.
szName | Name of the configuration property to be set. All supported public properties are defined in the config.h header file (#AI_CONFIG_XXX).
value | New value for the property
ASSIMP_API void aiTransformVecByMatrix3 | ( | aiVector3D * | vec,
 |  | const aiMatrix3x3 * | mat
 | ) |  |

Transform a vector by a 3x3 matrix.

Parameters:
vec | Vector to be transformed.
mat | Matrix to transform the vector with.
ASSIMP_API void aiTransformVecByMatrix4 | ( | aiVector3D * | vec,
 |  | const aiMatrix4x4 * | mat
 | ) |  |

Transform a vector by a 4x4 matrix.

Parameters:
vec | Vector to be transformed.
mat | Matrix to transform the vector with.
ASSIMP_API void aiTransposeMatrix3 ( aiMatrix3x3 * mat )

Transpose a 3x3 matrix.

Parameters:
mat Pointer to the matrix to be transposed
ASSIMP_API void aiTransposeMatrix4 ( aiMatrix4x4 * mat )

Transpose a 4x4 matrix.

Parameters:
mat Pointer to the matrix to be transposed


Assimp: color4.h File Reference

  • File List
  • File Members
Classes | Typedefs | Variables
color4.h File Reference

Classes

class | aiColor4t< TReal >
Represents a color in Red-Green-Blue space including an alpha component. More...

Typedefs

typedef aiColor4t< float > | aiColor4D

Variables

class aiColor4t | PACK_STRUCT

Typedef Documentation

typedef aiColor4t<float> aiColor4D

Variable Documentation

struct aiColor3D PACK_STRUCT


Assimp: color4.inl File Reference

  • File List
  • File Members
Defines | Functions
color4.inl File Reference

Defines

#define | AI_COLOR4D_INL_INC

Functions

template<typename TReal >
AI_FORCE_INLINE aiColor4t< TReal > | operator* (const aiColor4t< TReal > &v1, const aiColor4t< TReal > &v2)
template<typename TReal >
AI_FORCE_INLINE aiColor4t< TReal > | operator* (TReal f, const aiColor4t< TReal > &v)
template<typename TReal >
AI_FORCE_INLINE aiColor4t< TReal > | operator* (const aiColor4t< TReal > &v, TReal f)
template<typename TReal >
AI_FORCE_INLINE aiColor4t< TReal > | operator+ (const aiColor4t< TReal > &v, TReal f)
template<typename TReal >
AI_FORCE_INLINE aiColor4t< TReal > | operator+ (TReal f, const aiColor4t< TReal > &v)
template<typename TReal >
AI_FORCE_INLINE aiColor4t< TReal > | operator+ (const aiColor4t< TReal > &v1, const aiColor4t< TReal > &v2)
template<typename TReal >
AI_FORCE_INLINE aiColor4t< TReal > | operator- (TReal f, const aiColor4t< TReal > &v)
template<typename TReal >
AI_FORCE_INLINE aiColor4t< TReal > | operator- (const aiColor4t< TReal > &v, TReal f)
template<typename TReal >
AI_FORCE_INLINE aiColor4t< TReal > | operator- (const aiColor4t< TReal > &v1, const aiColor4t< TReal > &v2)
template<typename TReal >
AI_FORCE_INLINE aiColor4t< TReal > | operator/ (const aiColor4t< TReal > &v1, const aiColor4t< TReal > &v2)
template<typename TReal >
AI_FORCE_INLINE aiColor4t< TReal > | operator/ (const aiColor4t< TReal > &v, TReal f)
template<typename TReal >
AI_FORCE_INLINE aiColor4t< TReal > | operator/ (TReal f, const aiColor4t< TReal > &v)

Define Documentation

#define AI_COLOR4D_INL_INC

Function Documentation

template<typename TReal >
AI_FORCE_INLINE aiColor4t<TReal> operator* | ( | const aiColor4t< TReal > & | v1,
 |  | const aiColor4t< TReal > & | v2
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiColor4t<TReal> operator* | ( | TReal | f,
 |  | const aiColor4t< TReal > & | v
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiColor4t<TReal> operator* | ( | const aiColor4t< TReal > & | v,
 |  | TReal | f
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiColor4t<TReal> operator+ | ( | const aiColor4t< TReal > & | v,
 |  | TReal | f
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiColor4t<TReal> operator+ | ( | TReal | f,
 |  | const aiColor4t< TReal > & | v
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiColor4t<TReal> operator+ | ( | const aiColor4t< TReal > & | v1,
 |  | const aiColor4t< TReal > & | v2
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiColor4t<TReal> operator- | ( | TReal | f,
 |  | const aiColor4t< TReal > & | v
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiColor4t<TReal> operator- | ( | const aiColor4t< TReal > & | v,
 |  | TReal | f
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiColor4t<TReal> operator- | ( | const aiColor4t< TReal > & | v1,
 |  | const aiColor4t< TReal > & | v2
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiColor4t<TReal> operator/ | ( | const aiColor4t< TReal > & | v1,
 |  | const aiColor4t< TReal > & | v2
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiColor4t<TReal> operator/ | ( | const aiColor4t< TReal > & | v,
 |  | TReal | f
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiColor4t<TReal> operator/ | ( | TReal | f,
 |  | const aiColor4t< TReal > & | v
 | ) |  |


Assimp: config.h File Reference

  • File List
  • File Members
Defines | Enumerations
config.h File Reference

Defines constants for configurable properties for the library. More...

Defines

#define | AI_CONFIG_FAVOUR_SPEED "FAVOUR_SPEED"
A hint to assimp to favour speed against import quality.
#define | AI_CONFIG_GLOB_MEASURE_TIME "GLOB_MEASURE_TIME"
Enables time measurements.
#define | AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION "IMPORT_AC_EVAL_SUBDIVISION"
Configures whether the AC loader evaluates subdivision surfaces ( indicated by the presence of the 'subdiv' attribute in the file).
#define | AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL "IMPORT_AC_SEPARATE_BFCULL"
Configures the AC loader to collect all surfaces which have the "Backface cull" flag set in separate meshes.
#define | AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS "IMPORT_ASE_RECONSTRUCT_NORMALS"
Configures the ASE loader to always reconstruct normal vectors basing on the smoothing groups loaded from the file.
#define | AI_CONFIG_IMPORT_GLOBAL_KEYFRAME "IMPORT_GLOBAL_KEYFRAME"
Set the vertex animation keyframe to be imported.
#define | AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION "IMPORT_IFC_CUSTOM_TRIANGULATION"
Specifies whether the IFC loader will use its own, custom triangulation algorithm to triangulate wall and floor meshes.
#define | AI_CONFIG_IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS "IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS"
Specifies whether the IFC loader skips over shape representations of type 'Curve2D'.
#define | AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS "IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS"
Specifies whether the IFC loader skips over IfcSpace elements.
#define | AI_CONFIG_IMPORT_IRR_ANIM_FPS "IMPORT_IRR_ANIM_FPS"
Defines the output frame rate of the IRR loader.
#define | AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY "IMPORT_LWO_ONE_LAYER_ONLY"
Configures the LWO loader to load just one layer from the model.
#define | AI_CONFIG_IMPORT_LWS_ANIM_END "IMPORT_LWS_ANIM_END"
#define | AI_CONFIG_IMPORT_LWS_ANIM_START "IMPORT_LWS_ANIM_START"
Defines the begin of the time range for which the LWS loader evaluates animations and computes aiNodeAnim's.
#define | AI_CONFIG_IMPORT_MD2_KEYFRAME "IMPORT_MD2_KEYFRAME"
#define | AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART "IMPORT_MD3_HANDLE_MULTIPART"
Configures the M3D loader to detect and process multi-part Quake player models.
#define | AI_CONFIG_IMPORT_MD3_KEYFRAME "IMPORT_MD3_KEYFRAME"
#define | AI_CONFIG_IMPORT_MD3_SHADER_SRC "IMPORT_MD3_SHADER_SRC"
Specify the Quake 3 shader file to be used for a particular MD3 file.
#define | AI_CONFIG_IMPORT_MD3_SKIN_NAME "IMPORT_MD3_SKIN_NAME"
Tells the MD3 loader which skin files to load.
#define | AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD "IMPORT_MD5_NO_ANIM_AUTOLOAD"
Configures the MD5 loader to not load the MD5ANIM file for a MD5MESH file automatically.
#define | AI_CONFIG_IMPORT_MDC_KEYFRAME "IMPORT_MDC_KEYFRAME"
#define | AI_CONFIG_IMPORT_MDL_COLORMAP "IMPORT_MDL_COLORMAP"
Sets the colormap (= palette) to be used to decode embedded textures in MDL (Quake or 3DGS) files.
#define | AI_CONFIG_IMPORT_MDL_KEYFRAME "IMPORT_MDL_KEYFRAME"
#define | AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE "IMPORT_OGRE_MATERIAL_FILE"
Ogre Importer will try to load this Materialfile.
#define | AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME "IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME"
Ogre Importer detect the texture usage from its filename.
#define | AI_CONFIG_IMPORT_SMD_KEYFRAME "IMPORT_SMD_KEYFRAME"
#define | AI_CONFIG_IMPORT_TER_MAKE_UVS "IMPORT_TER_MAKE_UVS"
Configures the terragen import plugin to compute uv's for terrains, if not given.
#define | AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS "UNREAL_HANDLE_FLAGS"
Configures the UNREAL 3D loader to separate faces with different surface flags (e.g.
#define | AI_CONFIG_IMPORT_UNREAL_KEYFRAME "IMPORT_UNREAL_KEYFRAME"
#define | AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE "PP_CT_MAX_SMOOTHING_ANGLE"
Specifies the maximum angle that may be between two vertex tangents that their tangents and bi-tangents are smoothed.
#define | AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX "PP_CT_TEXTURE_CHANNEL_INDEX"
Source UV channel for tangent space computation.
#define | AI_CONFIG_PP_DB_ALL_OR_NONE "PP_DB_ALL_OR_NONE"
Require all bones qualify for deboning before removing any.
#define | AI_CONFIG_PP_DB_THRESHOLD "PP_DB_THRESHOLD"
Lower the deboning threshold in order to remove more bones.
#define | AI_CONFIG_PP_FD_REMOVE "PP_FD_REMOVE"
Configures the aiProcess_FindDegenerates step to remove degenerated primitives from the import - immediately.
#define | AI_CONFIG_PP_FID_ANIM_ACCURACY "PP_FID_ANIM_ACCURACY"
Input parameter to the aiProcess_FindInvalidData step: Specifies the floating-point accuracy for animation values.
#define | AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE "PP_GSN_MAX_SMOOTHING_ANGLE"
Specifies the maximum angle that may be between two face normals at the same vertex position that their are smoothed together.
#define | AI_CONFIG_PP_ICL_PTCACHE_SIZE "PP_ICL_PTCACHE_SIZE"
Set the size of the post-transform vertex cache to optimize the vertices for.
#define | AI_CONFIG_PP_LBW_MAX_WEIGHTS "PP_LBW_MAX_WEIGHTS"
Set the maximum number of bones affecting a single vertex.
#define | AI_CONFIG_PP_OG_EXCLUDE_LIST "PP_OG_EXCLUDE_LIST"
Configures the aiProcess_OptimizeGraph step to preserve nodes matching a name in a given list.
#define | AI_CONFIG_PP_PTV_KEEP_HIERARCHY "PP_PTV_KEEP_HIERARCHY"
Configures the #aiProcess_PretransformVertices step to keep the scene hierarchy.
#define | AI_CONFIG_PP_PTV_NORMALIZE "PP_PTV_NORMALIZE"
Configures the #aiProcess_PretransformVertices step to normalize all vertex components into the [-1,1] range.
#define | AI_CONFIG_PP_RRM_EXCLUDE_LIST "PP_RRM_EXCLUDE_LIST"
Configures the aiProcess_RemoveRedundantMaterials step to keep materials matching a name in a given list.
#define | AI_CONFIG_PP_RVC_FLAGS "PP_RVC_FLAGS"
Input parameter to the aiProcess_RemoveComponent step: Specifies the parts of the data structure to be removed.
#define | AI_CONFIG_PP_SBBC_MAX_BONES "PP_SBBC_MAX_BONES"
Maximum bone count per mesh for the SplitbyBoneCount step.
#define | AI_CONFIG_PP_SBP_REMOVE "PP_SBP_REMOVE"
Input parameter to the aiProcess_SortByPType step: Specifies which primitive types are removed by the step.
#define | AI_CONFIG_PP_SLM_TRIANGLE_LIMIT "PP_SLM_TRIANGLE_LIMIT"
Set the maximum number of triangles in a mesh.
#define | AI_CONFIG_PP_SLM_VERTEX_LIMIT "PP_SLM_VERTEX_LIMIT"
Set the maximum number of vertices in a mesh.
#define | AI_CONFIG_PP_TUV_EVALUATE "PP_TUV_EVALUATE"
Input parameter to the aiProcess_TransformUVCoords step: Specifies which UV transformations are evaluated.
#define | AI_DEBONE_THRESHOLD 1.0f
#define | AI_LMW_MAX_WEIGHTS 0x4
#define | AI_SBBC_DEFAULT_MAX_BONES 60
#define | AI_SLM_DEFAULT_MAX_TRIANGLES 1000000
#define | AI_SLM_DEFAULT_MAX_VERTICES 1000000
#define | AI_UVTRAFO_ALL (AI_UVTRAFO_SCALING | AI_UVTRAFO_ROTATION | AI_UVTRAFO_TRANSLATION)
#define | AI_UVTRAFO_ROTATION 0x2
#define | AI_UVTRAFO_SCALING 0x1
#define | AI_UVTRAFO_TRANSLATION 0x4
#define | aiComponent_COLORSn(n) (1u << (n+20u))
#define | aiComponent_TEXCOORDSn(n) (1u << (n+25u))
#define | PP_ICL_PTCACHE_SIZE 12
Default value for the AI_CONFIG_PP_ICL_PTCACHE_SIZE property.

Enumerations

enum aiComponent {
aiComponent_NORMALS = 0x2u, aiComponent_TANGENTS_AND_BITANGENTS = 0x4u, aiComponent_COLORS = 0x8, aiComponent_TEXCOORDS = 0x10,
aiComponent_BONEWEIGHTS = 0x20, aiComponent_ANIMATIONS = 0x40, aiComponent_TEXTURES = 0x80, aiComponent_LIGHTS = 0x100,
aiComponent_CAMERAS = 0x200, aiComponent_MESHES = 0x400, aiComponent_MATERIALS = 0x800, _aiComponent_Force32Bit = 0x9fffffff
}
Enumerates components of the aiScene and aiMesh data structures that can be excluded from the import using the #aiPrpcess_RemoveComponent step. More...

Detailed Description

Defines constants for configurable properties for the library.

Typically these properties are set via Assimp::Importer::SetPropertyFloat, Assimp::Importer::SetPropertyInteger or Assimp::Importer::SetPropertyString, depending on the data type of a property. All properties have a default value. See the doc for the mentioned methods for more details.

The corresponding functions for use with the plain-c API are: aiSetImportPropertyInteger, aiSetImportPropertyFloat, aiSetImportPropertyString

Define Documentation

#define AI_CONFIG_FAVOUR_SPEED "FAVOUR_SPEED"

A hint to assimp to favour speed against import quality.

Enabling this option may result in faster loading, but it needn't. It represents just a hint to loaders and post-processing steps to use faster code paths, if possible. This property is expected to be an integer, != 0 stands for true. The default value is 0.

#define AI_CONFIG_GLOB_MEASURE_TIME "GLOB_MEASURE_TIME"

Enables time measurements.

If enabled, measures the time needed for each part of the loading process (i.e. IO time, importing, postprocessing, ..) and dumps these timings to the DefaultLogger. See the Performance Page for more information on this topic.

Property type: bool. Default value: false.

#define AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION "IMPORT_AC_EVAL_SUBDIVISION"

Configures whether the AC loader evaluates subdivision surfaces ( indicated by the presence of the 'subdiv' attribute in the file).

By default, Assimp performs the subdivision using the standard Catmull-Clark algorithm

* Property type: bool. Default value: true.

#define AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL "IMPORT_AC_SEPARATE_BFCULL"

Configures the AC loader to collect all surfaces which have the "Backface cull" flag set in separate meshes.

Property type: bool. Default value: true.

#define AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS "IMPORT_ASE_RECONSTRUCT_NORMALS"

Configures the ASE loader to always reconstruct normal vectors basing on the smoothing groups loaded from the file.

Some ASE files have carry invalid normals, other don't. * Property type: bool. Default value: true.

#define AI_CONFIG_IMPORT_GLOBAL_KEYFRAME "IMPORT_GLOBAL_KEYFRAME"

Set the vertex animation keyframe to be imported.

ASSIMP does not support vertex keyframes (only bone animation is supported). The library reads only one frame of models with vertex animations. By default this is the first frame.

Note:
The default value is 0. This option applies to all importers. However, it is also possible to override the global setting for a specific loader. You can use the AI_CONFIG_IMPORT_XXX_KEYFRAME options (where XXX is a placeholder for the file format for which you want to override the global setting). Property type: integer.
#define AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION "IMPORT_IFC_CUSTOM_TRIANGULATION"

Specifies whether the IFC loader will use its own, custom triangulation algorithm to triangulate wall and floor meshes.

If this property is set to false, walls will be either triangulated by aiProcess_Triangulate or will be passed through as huge polygons with faked holes (i.e. holes that are connected with the outer boundary using a dummy edge). It is highly recommended to set this property to true if you want triangulated data because aiProcess_Triangulate is known to have problems with the kind of polygons that the IFC loader spits out for complicated meshes. Property type: Bool. Default value: true.

#define AI_CONFIG_IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS "IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS"

Specifies whether the IFC loader skips over shape representations of type 'Curve2D'.

A lot of files contain both a faceted mesh representation and a outline with a presentation type of 'Curve2D'. Currently Assimp doesn't convert those, so turning this option off just clutters the log with errors.
Property type: Bool. Default value: true.

#define AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS "IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS"

Specifies whether the IFC loader skips over IfcSpace elements.

IfcSpace elements (and their geometric representations) are used to represent, well, free space in a building storey.
Property type: Bool. Default value: true.

#define AI_CONFIG_IMPORT_IRR_ANIM_FPS "IMPORT_IRR_ANIM_FPS"

Defines the output frame rate of the IRR loader.

IRR animations are difficult to convert for Assimp and there will always be a loss of quality. This setting defines how many keys per second are returned by the converter.
Property type: integer. Default value: 100

#define AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY "IMPORT_LWO_ONE_LAYER_ONLY"

Configures the LWO loader to load just one layer from the model.

LWO files consist of layers and in some cases it could be useful to load only one of them. This property can be either a string - which specifies the name of the layer - or an integer - the index of the layer. If the property is not set the whole LWO model is loaded. Loading fails if the requested layer is not available. The layer index is zero-based and the layer name may not be empty.
Property type: Integer. Default value: all layers are loaded.

#define AI_CONFIG_IMPORT_LWS_ANIM_END "IMPORT_LWS_ANIM_END"
#define AI_CONFIG_IMPORT_LWS_ANIM_START "IMPORT_LWS_ANIM_START"

Defines the begin of the time range for which the LWS loader evaluates animations and computes aiNodeAnim's.

Assimp provides full conversion of LightWave's envelope system, including pre and post conditions. The loader computes linearly subsampled animation chanels with the frame rate given in the LWS file. This property defines the start time. Note: animation channels are only generated if a node has at least one envelope with more tan one key assigned. This property. is given in frames, '0' is the first frame. By default, if this property is not set, the importer takes the animation start from the input LWS file ('FirstFrame' line)
Property type: Integer. Default value: taken from file.

See also:
AI_CONFIG_IMPORT_LWS_ANIM_END - end of the imported time range
#define AI_CONFIG_IMPORT_MD2_KEYFRAME "IMPORT_MD2_KEYFRAME"
#define AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART "IMPORT_MD3_HANDLE_MULTIPART"

Configures the M3D loader to detect and process multi-part Quake player models.

These models usually consist of 3 files, lower.md3, upper.md3 and head.md3. If this property is set to true, Assimp will try to load and combine all three files if one of them is loaded. Property type: bool. Default value: true.

#define AI_CONFIG_IMPORT_MD3_KEYFRAME "IMPORT_MD3_KEYFRAME"
#define AI_CONFIG_IMPORT_MD3_SHADER_SRC "IMPORT_MD3_SHADER_SRC"

Specify the Quake 3 shader file to be used for a particular MD3 file.

This can also be a search path.

By default Assimp's behaviour is as follows: If a MD3 file <any_path>/models/<any_q3_subdir>/<model_name>/<file_name>.md3 is loaded, the library tries to locate the corresponding shader file in <any_path>/scripts/<model_name>.shader. This property overrides this behaviour. It can either specify a full path to the shader to be loaded or alternatively the path (relative or absolute) to the directory where the shaders for all MD3s to be loaded reside. Assimp attempts to open <dir>/<model_name>.shader first, <dir>/<file_name>.shader is the fallback file. Note that <dir> should have a terminal (back)slash. Property type: String. Default value: n/a.

#define AI_CONFIG_IMPORT_MD3_SKIN_NAME "IMPORT_MD3_SKIN_NAME"

Tells the MD3 loader which skin files to load.

When loading MD3 files, Assimp checks whether a file <md3_file_name>_<skin_name>.skin is existing. These files are used by Quake III to be able to assign different skins (e.g. red and blue team) to models. 'default', 'red', 'blue' are typical skin names. Property type: String. Default value: "default".

#define AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD "IMPORT_MD5_NO_ANIM_AUTOLOAD"

Configures the MD5 loader to not load the MD5ANIM file for a MD5MESH file automatically.

The default strategy is to look for a file with the same name but the MD5ANIM extension in the same directory. If it is found, it is loaded and combined with the MD5MESH file. This configuration option can be used to disable this behaviour.

* Property type: bool. Default value: false.

#define AI_CONFIG_IMPORT_MDC_KEYFRAME "IMPORT_MDC_KEYFRAME"
#define AI_CONFIG_IMPORT_MDL_COLORMAP "IMPORT_MDL_COLORMAP"

Sets the colormap (= palette) to be used to decode embedded textures in MDL (Quake or 3DGS) files.

This must be a valid path to a file. The file is 768 (256*3) bytes large and contains RGB triplets for each of the 256 palette entries. The default value is colormap.lmp. If the file is not found, a default palette (from Quake 1) is used. Property type: string.

#define AI_CONFIG_IMPORT_MDL_KEYFRAME "IMPORT_MDL_KEYFRAME"
#define AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE "IMPORT_OGRE_MATERIAL_FILE"

Ogre Importer will try to load this Materialfile.

Ogre Meshes contain only the MaterialName, not the MaterialFile. If there is no material file with the same name as the material, Ogre Importer will try to load this file and search the material in it.
Property type: String. Default value: guessed.

#define AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME "IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME"

Ogre Importer detect the texture usage from its filename.

Normally, a texture is loaded as a colormap, if no target is specified in the materialfile. Is this switch is enabled, texture names ending with _n, _l, _s are used as normalmaps, lightmaps or specularmaps.
Property type: Bool. Default value: false.

#define AI_CONFIG_IMPORT_SMD_KEYFRAME "IMPORT_SMD_KEYFRAME"
#define AI_CONFIG_IMPORT_TER_MAKE_UVS "IMPORT_TER_MAKE_UVS"

Configures the terragen import plugin to compute uv's for terrains, if not given.

Furthermore a default texture is assigned.

UV coordinates for terrains are so simple to compute that you'll usually want to compute them on your own, if you need them. This option is intended for model viewers which want to offer an easy way to apply textures to terrains. * Property type: bool. Default value: false.

#define AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS "UNREAL_HANDLE_FLAGS"

Configures the UNREAL 3D loader to separate faces with different surface flags (e.g.

two-sided vs. single-sided).

* Property type: bool. Default value: true.

#define AI_CONFIG_IMPORT_UNREAL_KEYFRAME "IMPORT_UNREAL_KEYFRAME"
#define AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE "PP_CT_MAX_SMOOTHING_ANGLE"

Specifies the maximum angle that may be between two vertex tangents that their tangents and bi-tangents are smoothed.

This applies to the CalcTangentSpace-Step. The angle is specified in degrees. The maximum value is 175. Property type: float. Default value: 45 degrees

#define AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX "PP_CT_TEXTURE_CHANNEL_INDEX"

Source UV channel for tangent space computation.

The specified channel must exist or an error will be raised. Property type: integer. Default value: 0

#define AI_CONFIG_PP_DB_ALL_OR_NONE "PP_DB_ALL_OR_NONE"

Require all bones qualify for deboning before removing any.

This is used by the aiProcess_Debone PostProcess-Step.

Note:
The default value is 0 Property type: bool.
#define AI_CONFIG_PP_DB_THRESHOLD "PP_DB_THRESHOLD"

Lower the deboning threshold in order to remove more bones.

This is used by the aiProcess_Debone PostProcess-Step.

Note:
The default value is AI_DEBONE_THRESHOLD Property type: float.
#define AI_CONFIG_PP_FD_REMOVE "PP_FD_REMOVE"

Configures the aiProcess_FindDegenerates step to remove degenerated primitives from the import - immediately.

The default behaviour converts degenerated triangles to lines and degenerated lines to points. See the documentation to the aiProcess_FindDegenerates step for a detailed example of the various ways to get rid of these lines and points if you don't want them. Property type: bool. Default value: false.

#define AI_CONFIG_PP_FID_ANIM_ACCURACY "PP_FID_ANIM_ACCURACY"

Input parameter to the aiProcess_FindInvalidData step: Specifies the floating-point accuracy for animation values.

The step checks for animation tracks where all frame values are absolutely equal and removes them. This tweakable controls the epsilon for floating-point comparisons - two keys are considered equal if the invariant abs(n0-n1)>epsilon holds true for all vector respectively quaternion components. The default value is 0.f - comparisons are exact then.

#define AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE "PP_GSN_MAX_SMOOTHING_ANGLE"

Specifies the maximum angle that may be between two face normals at the same vertex position that their are smoothed together.

Sometimes referred to as 'crease angle'. This applies to the GenSmoothNormals-Step. The angle is specified in degrees, so 180 is PI. The default value is 175 degrees (all vertex normals are smoothed). The maximum value is 175, too. Property type: float. Warning: setting this option may cause a severe loss of performance. The performance is unaffected if the AI_CONFIG_FAVOUR_SPEED flag is set but the output quality may be reduced.

#define AI_CONFIG_PP_ICL_PTCACHE_SIZE "PP_ICL_PTCACHE_SIZE"

Set the size of the post-transform vertex cache to optimize the vertices for.

This configures the aiProcess_ImproveCacheLocality step.

The size is given in vertices. Of course you can't know how the vertex format will exactly look like after the import returns, but you can still guess what your meshes will probably have.

Note:
The default value is PP_ICL_PTCACHE_SIZE. That results in slight performance improvements for most nVidia/AMD cards since 2002. Property type: integer.
#define AI_CONFIG_PP_LBW_MAX_WEIGHTS "PP_LBW_MAX_WEIGHTS"

Set the maximum number of bones affecting a single vertex.

This is used by the aiProcess_LimitBoneWeights PostProcess-Step.

Note:
The default value is AI_LBW_MAX_WEIGHTS Property type: integer.
#define AI_CONFIG_PP_OG_EXCLUDE_LIST "PP_OG_EXCLUDE_LIST"

Configures the aiProcess_OptimizeGraph step to preserve nodes matching a name in a given list.

This is a list of 1 to n strings, ' ' serves as delimiter character. Identifiers containing whitespaces must be enclosed in *single* quotation marks. For example: "keep-me and_me_to anotherNodeToBeKept \'name with whitespace\'". If a node matches on of these names, it will not be modified or removed by the postprocessing step.
This option might be useful if you are using some magic node names to pass additional semantics through the content pipeline. This ensures they won't be optimized away, but a general optimization is still performed for nodes not contained in the list. Property type: String. Default value: n/a

Note:
Linefeeds, tabs or carriage returns are treated as whitespace. Node names are case sensitive.
#define AI_CONFIG_PP_PTV_KEEP_HIERARCHY "PP_PTV_KEEP_HIERARCHY"

Configures the #aiProcess_PretransformVertices step to keep the scene hierarchy.

Meshes are moved to worldspace, but no optimization is performed (read: meshes with equal materials are not joined. The total number of meshes won't change).

This option could be of use for you if the scene hierarchy contains important additional information which you intend to parse. For rendering, you can still render all meshes in the scene without any transformations. Property type: bool. Default value: false.

#define AI_CONFIG_PP_PTV_NORMALIZE "PP_PTV_NORMALIZE"

Configures the #aiProcess_PretransformVertices step to normalize all vertex components into the [-1,1] range.

That is, a bounding box for the whole scene is computed, the maximum component is taken and all meshes are scaled appropriately (uniformly of course!). This might be useful if you don't know the spatial dimension of the input data

#define AI_CONFIG_PP_RRM_EXCLUDE_LIST "PP_RRM_EXCLUDE_LIST"

Configures the aiProcess_RemoveRedundantMaterials step to keep materials matching a name in a given list.

This is a list of 1 to n strings, ' ' serves as delimiter character. Identifiers containing whitespaces must be enclosed in *single* quotation marks. For example: "keep-me and_me_to anotherMaterialToBeKept \'name with whitespace\'". If a material matches on of these names, it will not be modified or removed by the postprocessing step nor will other materials be replaced by a reference to it.
This option might be useful if you are using some magic material names to pass additional semantics through the content pipeline. This ensures they won't be optimized away, but a general optimization is still performed for materials not contained in the list. Property type: String. Default value: n/a

Note:
Linefeeds, tabs or carriage returns are treated as whitespace. Material names are case sensitive.
#define AI_CONFIG_PP_RVC_FLAGS "PP_RVC_FLAGS"

Input parameter to the aiProcess_RemoveComponent step: Specifies the parts of the data structure to be removed.

See the documentation to this step for further details. The property is expected to be an integer, a bitwise combination of the aiComponent flags defined above in this header. The default value is 0. Important: if no valid mesh is remaining after the step has been executed (e.g you thought it was funny to specify ALL of the flags defined above) the import FAILS. Mainly because there is no data to work on anymore ...

#define AI_CONFIG_PP_SBBC_MAX_BONES "PP_SBBC_MAX_BONES"

Maximum bone count per mesh for the SplitbyBoneCount step.

Meshes are split until the maximum number of bones is reached. The default value is AI_SBBC_DEFAULT_MAX_BONES, which may be altered at compile-time. Property data type: integer.

#define AI_CONFIG_PP_SBP_REMOVE "PP_SBP_REMOVE"

Input parameter to the aiProcess_SortByPType step: Specifies which primitive types are removed by the step.

This is a bitwise combination of the aiPrimitiveType flags. Specifying all of them is illegal, of course. A typical use would be to exclude all line and point meshes from the import. This is an integer property, its default value is 0.

#define AI_CONFIG_PP_SLM_TRIANGLE_LIMIT "PP_SLM_TRIANGLE_LIMIT"

Set the maximum number of triangles in a mesh.

This is used by the "SplitLargeMeshes" PostProcess-Step to determine whether a mesh must be split or not.

Note:
The default value is AI_SLM_DEFAULT_MAX_TRIANGLES Property type: integer.
#define AI_CONFIG_PP_SLM_VERTEX_LIMIT "PP_SLM_VERTEX_LIMIT"

Set the maximum number of vertices in a mesh.

This is used by the "SplitLargeMeshes" PostProcess-Step to determine whether a mesh must be split or not.

Note:
The default value is AI_SLM_DEFAULT_MAX_VERTICES Property type: integer.
#define AI_CONFIG_PP_TUV_EVALUATE "PP_TUV_EVALUATE"

Input parameter to the aiProcess_TransformUVCoords step: Specifies which UV transformations are evaluated.

This is a bitwise combination of the AI_UVTRAFO_XXX flags (integer property, of course). By default all transformations are enabled (AI_UVTRAFO_ALL).

#define AI_DEBONE_THRESHOLD 1.0f
#define AI_LMW_MAX_WEIGHTS 0x4
#define AI_SBBC_DEFAULT_MAX_BONES 60
#define AI_SLM_DEFAULT_MAX_TRIANGLES 1000000
#define AI_SLM_DEFAULT_MAX_VERTICES 1000000
#define AI_UVTRAFO_ALL (AI_UVTRAFO_SCALING | AI_UVTRAFO_ROTATION | AI_UVTRAFO_TRANSLATION)
#define AI_UVTRAFO_ROTATION 0x2
#define AI_UVTRAFO_SCALING 0x1
#define AI_UVTRAFO_TRANSLATION 0x4
#define aiComponent_COLORSn ( n ) (1u << (n+20u))
#define aiComponent_TEXCOORDSn ( n ) (1u << (n+25u))
#define PP_ICL_PTCACHE_SIZE 12

Default value for the AI_CONFIG_PP_ICL_PTCACHE_SIZE property.

Enumeration Type Documentation

enum aiComponent

Enumerates components of the aiScene and aiMesh data structures that can be excluded from the import using the #aiPrpcess_RemoveComponent step.

See the documentation to aiProcess_RemoveComponent for more details.

Enumerator:
aiComponent_NORMALS

Normal vectors.

aiComponent_TANGENTS_AND_BITANGENTS

Tangents and bitangents go always together ...

aiComponent_COLORS

ALL color sets Use aiComponent_COLORn(N) to specify the N'th set.

aiComponent_TEXCOORDS

ALL texture UV sets aiComponent_TEXCOORDn(N) to specify the N'th set.

aiComponent_BONEWEIGHTS

Removes all bone weights from all meshes.

The scenegraph nodes corresponding to the bones are NOT removed. use the aiProcess_OptimizeGraph step to do this

aiComponent_ANIMATIONS

Removes all node animations (aiScene::mAnimations).

The corresponding scenegraph nodes are NOT removed. use the aiProcess_OptimizeGraph step to do this

aiComponent_TEXTURES

Removes all embedded textures (aiScene::mTextures)

aiComponent_LIGHTS

Removes all light sources (aiScene::mLights).

The corresponding scenegraph nodes are NOT removed. use the aiProcess_OptimizeGraph step to do this

aiComponent_CAMERAS

Removes all light sources (aiScene::mCameras).

The corresponding scenegraph nodes are NOT removed. use the aiProcess_OptimizeGraph step to do this

aiComponent_MESHES

Removes all meshes (aiScene::mMeshes).

aiComponent_MATERIALS

Removes all materials.

One default material will be generated, so aiScene::mNumMaterials will be 1.

_aiComponent_Force32Bit

This value is not used.

It is just there to force the compiler to map this enum to a 32 Bit integer.


Assimp: DefaultLogger.hpp File Reference

  • File List
  • File Members
Classes | Namespaces | Defines
DefaultLogger.hpp File Reference

Classes

class | Assimp::DefaultLogger
CPP-API: Primary logging facility of Assimp. More...

Namespaces

namespace | Assimp

Assimp's CPP-API and all internal APIs.

Defines

#define | ASSIMP_DEFAULT_LOG_NAME "AssimpLog.txt"
default name of logfile

Define Documentation

#define ASSIMP_DEFAULT_LOG_NAME "AssimpLog.txt"

default name of logfile


Assimp: defs.h File Reference

  • File List
  • File Members
Defines
defs.h File Reference

Defines

#define | AI_DEG_TO_RAD(x) (x*0.0174532925f)
#define | AI_FORCE_INLINE inline
#define | AI_MATH_HALF_PI (AI_MATH_PI * 0.5)
#define | AI_MATH_HALF_PI_F (AI_MATH_PI_F * 0.5f)
#define | AI_MATH_PI (3.141592653589793238462643383279 )
#define | AI_MATH_PI_F (3.1415926538f)
#define | AI_MATH_TWO_PI (AI_MATH_PI * 2.0)
#define | AI_MATH_TWO_PI_F (AI_MATH_PI_F * 2.0f)
#define | AI_RAD_TO_DEG(x) (x*57.2957795f)
#define | AI_WONT_RETURN
#define | ASSIMP_API __attribute__ ((visibility("default")))
#define | ASSIMP_API_WINONLY
#define | ASSIMP_BUILD_NEED_Z_INFLATE
#define | ASSIMP_BUILD_NEED_Z_INFLATE
#define | ASSIMP_BUILD_SINGLETHREADED
#define | C_ENUM
#define | C_STRUCT

Define Documentation

#define AI_DEG_TO_RAD ( x ) (x*0.0174532925f)
#define AI_FORCE_INLINE inline
#define AI_MATH_HALF_PI (AI_MATH_PI * 0.5)
#define AI_MATH_HALF_PI_F (AI_MATH_PI_F * 0.5f)
#define AI_MATH_PI (3.141592653589793238462643383279 )
#define AI_MATH_PI_F (3.1415926538f)
#define AI_MATH_TWO_PI (AI_MATH_PI * 2.0)
#define AI_MATH_TWO_PI_F (AI_MATH_PI_F * 2.0f)
#define AI_RAD_TO_DEG ( x ) (x*57.2957795f)
#define AI_WONT_RETURN
#define ASSIMP_API __attribute__ ((visibility("default")))
#define ASSIMP_API_WINONLY
#define ASSIMP_BUILD_NEED_Z_INFLATE
#define ASSIMP_BUILD_NEED_Z_INFLATE
#define ASSIMP_BUILD_SINGLETHREADED
#define C_ENUM
#define C_STRUCT


Assimp: dox.h File Reference

  • File List
  • File Members
dox.h File Reference

General documentation built from a doxygen comment. More...

Detailed Description

General documentation built from a doxygen comment.


Assimp: Exporter.hpp File Reference

  • File List
  • File Members
Classes | Namespaces
Exporter.hpp File Reference

Classes

class | Assimp::Exporter
CPP-API: The Exporter class forms an C++ interface to the export functionality of the Open Asset Import Library. More...
struct | Assimp::Exporter::ExportFormatEntry
Internal description of an Assimp export format option. More...

Namespaces

namespace | Assimp

Assimp's CPP-API and all internal APIs.


Assimp: Importer.hpp File Reference

  • File List
  • File Members
Classes | Namespaces | Defines
Importer.hpp File Reference

Classes

class | Assimp::Importer
CPP-API: The Importer class forms an C++ interface to the functionality of the Open Asset Import Library. More...

Namespaces

namespace | Assimp

Assimp's CPP-API and all internal APIs.

Defines

#define | AI_PROPERTY_WAS_NOT_EXISTING 0xffffffff
namespace Assimp

Define Documentation

#define AI_PROPERTY_WAS_NOT_EXISTING 0xffffffff

namespace Assimp


Assimp: importerdesc.h File Reference

  • File List
  • File Members
Classes | Enumerations
importerdesc.h File Reference

aiImporterFlags, aiImporterDesc implementation. More...

Classes

struct aiImporterDesc
Meta information about a particular importer. More...

Enumerations

enum aiImporterFlags {
aiImporterFlags_SupportTextFlavour = 0x1, aiImporterFlags_SupportBinaryFlavour = 0x2, aiImporterFlags_SupportCompressedFlavour = 0x4, aiImporterFlags_LimitedSupport = 0x8,
aiImporterFlags_Experimental = 0x10
}
Mixed set of flags for aiImporterDesc, indicating some features common to many importers. More...

Detailed Description

aiImporterFlags, aiImporterDesc implementation.

Enumeration Type Documentation

enum aiImporterFlags

Mixed set of flags for aiImporterDesc, indicating some features common to many importers.

Enumerator:
aiImporterFlags_SupportTextFlavour

Indicates that there is a textual encoding of the file format; and that it is supported.

aiImporterFlags_SupportBinaryFlavour

Indicates that there is a binary encoding of the file format; and that it is supported.

aiImporterFlags_SupportCompressedFlavour

Indicates that there is a compressed encoding of the file format; and that it is supported.

aiImporterFlags_LimitedSupport

Indicates that the importer reads only a very particular subset of the file format.

This happens commonly for declarative or procedural formats which cannot easily be mapped to aiScene

aiImporterFlags_Experimental

Indicates that the importer is highly experimental and should be used with care.

This only happens for trunk (i.e. SVN) versions, experimental code is not included in releases.


Assimp: IOStream.hpp File Reference

  • File List
  • File Members
Classes | Namespaces
IOStream.hpp File Reference

Classes

class | Assimp::IOStream
CPP-API: Class to handle file I/O for C++. More...

Namespaces

namespace | Assimp

Assimp's CPP-API and all internal APIs.


Assimp: IOSystem.hpp File Reference

  • File List
  • File Members
Classes | Namespaces
IOSystem.hpp File Reference

Classes

class | Assimp::IOSystem
CPP-API: Interface to the file system. More...

Namespaces

namespace | Assimp

Assimp's CPP-API and all internal APIs.


Assimp: light.h File Reference

  • File List
  • File Members
Classes | Enumerations
light.h File Reference

Defines the aiLight data structure. More...

Classes

struct aiLight
Helper structure to describe a light source. More...

Enumerations

enum aiLightSourceType {
aiLightSource_UNDEFINED = 0x0, aiLightSource_DIRECTIONAL = 0x1, aiLightSource_POINT = 0x2, aiLightSource_SPOT = 0x3,
_aiLightSource_Force32Bit = 0x9fffffff
}
Enumerates all supported types of light sources. More...

Detailed Description

Defines the aiLight data structure.

Enumeration Type Documentation

enum aiLightSourceType

Enumerates all supported types of light sources.

Enumerator:
aiLightSource_UNDEFINED
aiLightSource_DIRECTIONAL

A directional light source has a well-defined direction but is infinitely far away.

That's quite a good approximation for sun light.

aiLightSource_POINT

A point light source has a well-defined position in space but no direction - it emits light in all directions.

A normal bulb is a point light.

aiLightSource_SPOT

A spot light source emits light in a specific angle.

It has a position and a direction it is pointing to. A good example for a spot light is a light spot in sport arenas.

_aiLightSource_Force32Bit

This value is not used.

It is just there to force the compiler to map this enum to a 32 Bit integer.


Assimp: Logger.hpp File Reference

  • File List
  • File Members
Classes | Namespaces | Defines
Logger.hpp File Reference

Abstract base class 'Logger', base of the logging system. More...

Classes

class | Assimp::Logger
CPP-API: Abstract interface for logger implementations. More...

Namespaces

namespace | Assimp

Assimp's CPP-API and all internal APIs.

Defines

#define | MAX_LOG_MESSAGE_LENGTH 1024u

Detailed Description

Abstract base class 'Logger', base of the logging system.

Define Documentation

#define MAX_LOG_MESSAGE_LENGTH 1024u


Assimp: LogStream.hpp File Reference

  • File List
  • File Members
Classes | Namespaces
LogStream.hpp File Reference

Classes

class | Assimp::LogStream
CPP-API: Abstract interface for log stream implementations. More...

Namespaces

namespace | Assimp

Assimp's CPP-API and all internal APIs.


Assimp: material.h File Reference

  • File List
  • File Members
Classes | Defines | Enumerations | Variables
material.h File Reference

Defines the material system of the library. More...

Classes

struct | aiMaterial
Data structure for a material. More...
struct | aiUVTransform
Defines how an UV channel is transformed. More...

Defines

#define | AI_DEFAULT_MATERIAL_NAME "DefaultMaterial"
#define | AI_MATKEY_BLEND_FUNC "$mat.blend",0,0
#define | AI_MATKEY_BUMPSCALING "$mat.bumpscaling",0,0
#define | AI_MATKEY_COLOR_AMBIENT "$clr.ambient",0,0
#define | AI_MATKEY_COLOR_DIFFUSE "$clr.diffuse",0,0
#define | AI_MATKEY_COLOR_EMISSIVE "$clr.emissive",0,0
#define | AI_MATKEY_COLOR_REFLECTIVE "$clr.reflective",0,0
#define | AI_MATKEY_COLOR_SPECULAR "$clr.specular",0,0
#define | AI_MATKEY_COLOR_TRANSPARENT "$clr.transparent",0,0
#define | AI_MATKEY_ENABLE_WIREFRAME "$mat.wireframe",0,0
#define | AI_MATKEY_GLOBAL_BACKGROUND_IMAGE "?bg.global",0,0
#define | AI_MATKEY_MAPPING(type, N) _AI_MATKEY_MAPPING_BASE,type,N
#define | AI_MATKEY_MAPPINGMODE_U(type, N) _AI_MATKEY_MAPPINGMODE_U_BASE,type,N
#define | AI_MATKEY_MAPPINGMODE_V(type, N) _AI_MATKEY_MAPPINGMODE_V_BASE,type,N
#define | AI_MATKEY_NAME "?mat.name",0,0
#define | AI_MATKEY_OPACITY "$mat.opacity",0,0
#define | AI_MATKEY_REFLECTIVITY "$mat.reflectivity",0,0
#define | AI_MATKEY_REFRACTI "$mat.refracti",0,0
#define | AI_MATKEY_SHADING_MODEL "$mat.shadingm",0,0
#define | AI_MATKEY_SHININESS "$mat.shininess",0,0
#define | AI_MATKEY_SHININESS_STRENGTH "$mat.shinpercent",0,0
#define | AI_MATKEY_TEXBLEND(type, N) _AI_MATKEY_TEXBLEND_BASE,type,N
#define | AI_MATKEY_TEXFLAGS(type, N) _AI_MATKEY_TEXFLAGS_BASE,type,N
#define | AI_MATKEY_TEXMAP_AXIS(type, N) _AI_MATKEY_TEXMAP_AXIS_BASE,type,N
#define | AI_MATKEY_TEXOP(type, N) _AI_MATKEY_TEXOP_BASE,type,N
#define | AI_MATKEY_TEXTURE(type, N) _AI_MATKEY_TEXTURE_BASE,type,N
#define | AI_MATKEY_TWOSIDED "$mat.twosided",0,0
#define | AI_MATKEY_UVTRANSFORM(type, N) _AI_MATKEY_UVTRANSFORM_BASE,type,N
#define | AI_MATKEY_UVWSRC(type, N) _AI_MATKEY_UVWSRC_BASE,type,N
#define | AI_TEXTURE_TYPE_MAX aiTextureType_UNKNOWN

Enumerations

enum | aiBlendMode { aiBlendMode_Default = 0x0, aiBlendMode_Additive = 0x1 }
Defines alpha-blend flags. More...
enum aiShadingMode {
aiShadingMode_Flat = 0x1, aiShadingMode_Gouraud = 0x2, aiShadingMode_Phong = 0x3, aiShadingMode_Blinn = 0x4,
aiShadingMode_Toon = 0x5, aiShadingMode_OrenNayar = 0x6, aiShadingMode_Minnaert = 0x7, aiShadingMode_CookTorrance = 0x8,
aiShadingMode_NoShading = 0x9, aiShadingMode_Fresnel = 0xa
}
Defines all shading models supported by the library. More...
enum | aiTextureFlags { aiTextureFlags_Invert = 0x1, aiTextureFlags_UseAlpha = 0x2, aiTextureFlags_IgnoreAlpha = 0x4 }
Defines some mixed flags for a particular texture. More...
enum | aiTextureMapMode { aiTextureMapMode_Wrap = 0x0, aiTextureMapMode_Clamp = 0x1, aiTextureMapMode_Decal = 0x3, aiTextureMapMode_Mirror = 0x2 }
Defines how UV coordinates outside the [0...1] range are handled. More...
enum aiTextureMapping {
aiTextureMapping_UV = 0x0, aiTextureMapping_SPHERE = 0x1, aiTextureMapping_CYLINDER = 0x2, aiTextureMapping_BOX = 0x3,
aiTextureMapping_PLANE = 0x4, aiTextureMapping_OTHER = 0x5
}
Defines how the mapping coords for a texture are generated. More...
enum aiTextureOp {
aiTextureOp_Multiply = 0x0, aiTextureOp_Add = 0x1, aiTextureOp_Subtract = 0x2, aiTextureOp_Divide = 0x3,
aiTextureOp_SmoothAdd = 0x4, aiTextureOp_SignedAdd = 0x5
}
Defines how the Nth texture of a specific type is combined with the result of all previous layers. More...
enum aiTextureType {
aiTextureType_NONE = 0x0, aiTextureType_DIFFUSE = 0x1, aiTextureType_SPECULAR = 0x2, aiTextureType_AMBIENT = 0x3,
aiTextureType_EMISSIVE = 0x4, aiTextureType_HEIGHT = 0x5, aiTextureType_NORMALS = 0x6, aiTextureType_SHININESS = 0x7,
aiTextureType_OPACITY = 0x8, aiTextureType_DISPLACEMENT = 0x9, aiTextureType_LIGHTMAP = 0xA, aiTextureType_REFLECTION = 0xB,
aiTextureType_UNKNOWN = 0xC
}
Defines the purpose of a texture. More...

Variables

struct aiUVTransform | PACK_STRUCT

Detailed Description

Defines the material system of the library.

Define Documentation

#define AI_DEFAULT_MATERIAL_NAME "DefaultMaterial"
#define AI_MATKEY_BLEND_FUNC "$mat.blend",0,0
#define AI_MATKEY_BUMPSCALING "$mat.bumpscaling",0,0
#define AI_MATKEY_COLOR_AMBIENT "$clr.ambient",0,0
#define AI_MATKEY_COLOR_DIFFUSE "$clr.diffuse",0,0
#define AI_MATKEY_COLOR_EMISSIVE "$clr.emissive",0,0
#define AI_MATKEY_COLOR_REFLECTIVE "$clr.reflective",0,0
#define AI_MATKEY_COLOR_SPECULAR "$clr.specular",0,0
#define AI_MATKEY_COLOR_TRANSPARENT "$clr.transparent",0,0
#define AI_MATKEY_ENABLE_WIREFRAME "$mat.wireframe",0,0
#define AI_MATKEY_GLOBAL_BACKGROUND_IMAGE "?bg.global",0,0
#define AI_MATKEY_MAPPING | ( | type,
 |  | N
 | ) | _AI_MATKEY_MAPPING_BASE,type,N
#define AI_MATKEY_MAPPINGMODE_U | ( | type,
 |  | N
 | ) | _AI_MATKEY_MAPPINGMODE_U_BASE,type,N
#define AI_MATKEY_MAPPINGMODE_V | ( | type,
 |  | N
 | ) | _AI_MATKEY_MAPPINGMODE_V_BASE,type,N
#define AI_MATKEY_NAME "?mat.name",0,0
#define AI_MATKEY_OPACITY "$mat.opacity",0,0
#define AI_MATKEY_REFLECTIVITY "$mat.reflectivity",0,0
#define AI_MATKEY_REFRACTI "$mat.refracti",0,0
#define AI_MATKEY_SHADING_MODEL "$mat.shadingm",0,0
#define AI_MATKEY_SHININESS "$mat.shininess",0,0
#define AI_MATKEY_SHININESS_STRENGTH "$mat.shinpercent",0,0
#define AI_MATKEY_TEXBLEND | ( | type,
 |  | N
 | ) | _AI_MATKEY_TEXBLEND_BASE,type,N
#define AI_MATKEY_TEXFLAGS | ( | type,
 |  | N
 | ) | _AI_MATKEY_TEXFLAGS_BASE,type,N
#define AI_MATKEY_TEXMAP_AXIS | ( | type,
 |  | N
 | ) | _AI_MATKEY_TEXMAP_AXIS_BASE,type,N
#define AI_MATKEY_TEXOP | ( | type,
 |  | N
 | ) | _AI_MATKEY_TEXOP_BASE,type,N
#define AI_MATKEY_TEXTURE | ( | type,
 |  | N
 | ) | _AI_MATKEY_TEXTURE_BASE,type,N
#define AI_MATKEY_TWOSIDED "$mat.twosided",0,0
#define AI_MATKEY_UVTRANSFORM | ( | type,
 |  | N
 | ) | _AI_MATKEY_UVTRANSFORM_BASE,type,N
#define AI_MATKEY_UVWSRC | ( | type,
 |  | N
 | ) | _AI_MATKEY_UVWSRC_BASE,type,N
#define AI_TEXTURE_TYPE_MAX aiTextureType_UNKNOWN

Enumeration Type Documentation

enum aiBlendMode

Defines alpha-blend flags.

If you're familiar with OpenGL or D3D, these flags aren't new to you. They define *how* the final color value of a pixel is computed, basing on the previous color at that pixel and the new color value from the material. The blend formula is:

    SourceColor * SourceBlend + DestColor * DestBlend

where <DestColor> is the previous color in the framebuffer at this position and <SourceColor> is the material colro before the transparency calculation.
This corresponds to the AI_MATKEY_BLEND_FUNC property.

Enumerator:
aiBlendMode_Default

Formula:

  SourceColor*SourceAlpha + DestColor*(1-SourceAlpha)
aiBlendMode_Additive

Additive blending.

Formula:

  SourceColor*1 + DestColor*1
enum aiShadingMode

Defines all shading models supported by the library.

The list of shading modes has been taken from Blender. See Blender documentation for more information. The API does not distinguish between "specular" and "diffuse" shaders (thus the specular term for diffuse shading models like Oren-Nayar remains undefined).
Again, this value is just a hint. Assimp tries to select the shader whose most common implementation matches the original rendering results of the 3D modeller which wrote a particular model as closely as possible.

Enumerator:
aiShadingMode_Flat

Flat shading.

Shading is done on per-face base, diffuse only. Also known as 'faceted shading'.

aiShadingMode_Gouraud

Simple Gouraud shading.

aiShadingMode_Phong

Phong-Shading -.

aiShadingMode_Blinn

Phong-Blinn-Shading.

aiShadingMode_Toon

Toon-Shading per pixel.

Also known as 'comic' shader.

aiShadingMode_OrenNayar

OrenNayar-Shading per pixel.

Extension to standard Lambertian shading, taking the roughness of the material into account

aiShadingMode_Minnaert

Minnaert-Shading per pixel.

Extension to standard Lambertian shading, taking the "darkness" of the material into account

aiShadingMode_CookTorrance

CookTorrance-Shading per pixel.

Special shader for metallic surfaces.

aiShadingMode_NoShading

No shading at all.

Constant light influence of 1.0.

aiShadingMode_Fresnel

Fresnel shading.

enum aiTextureFlags

Defines some mixed flags for a particular texture.

Usually you'll instruct your cg artists how textures have to look like ... and how they will be processed in your application. However, if you use Assimp for completely generic loading purposes you might also need to process these flags in order to display as many 'unknown' 3D models as possible correctly.

This corresponds to the AI_MATKEY_TEXFLAGS property.

Enumerator:
aiTextureFlags_Invert

The texture's color values have to be inverted (componentwise 1-n)

aiTextureFlags_UseAlpha

Explicit request to the application to process the alpha channel of the texture.

Mutually exclusive with aiTextureFlags_IgnoreAlpha. These flags are set if the library can say for sure that the alpha channel is used/is not used. If the model format does not define this, it is left to the application to decide whether the texture alpha channel - if any - is evaluated or not.

aiTextureFlags_IgnoreAlpha

Explicit request to the application to ignore the alpha channel of the texture.

Mutually exclusive with aiTextureFlags_UseAlpha.

enum aiTextureMapMode

Defines how UV coordinates outside the [0...1] range are handled.

Commonly refered to as 'wrapping mode'.

Enumerator:
aiTextureMapMode_Wrap

A texture coordinate u|v is translated to u%1|v%1.

aiTextureMapMode_Clamp

Texture coordinates outside [0...1] are clamped to the nearest valid value.

aiTextureMapMode_Decal

If the texture coordinates for a pixel are outside [0...1] the texture is not applied to that pixel.

aiTextureMapMode_Mirror

A texture coordinate u|v becomes u%1|v%1 if (u-(u%1))%2 is zero and 1-(u%1)|1-(v%1) otherwise.

enum aiTextureMapping

Defines how the mapping coords for a texture are generated.

Real-time applications typically require full UV coordinates, so the use of the aiProcess_GenUVCoords step is highly recommended. It generates proper UV channels for non-UV mapped objects, as long as an accurate description how the mapping should look like (e.g spherical) is given. See the AI_MATKEY_MAPPING property for more details.

Enumerator:
aiTextureMapping_UV

The mapping coordinates are taken from an UV channel.

The AI_MATKEY_UVWSRC key specifies from which UV channel the texture coordinates are to be taken from (remember, meshes can have more than one UV channel).

aiTextureMapping_SPHERE

Spherical mapping.

aiTextureMapping_CYLINDER

Cylindrical mapping.

aiTextureMapping_BOX

Cubic mapping.

aiTextureMapping_PLANE

Planar mapping.

aiTextureMapping_OTHER

Undefined mapping.

Have fun.

enum aiTextureOp

Defines how the Nth texture of a specific type is combined with the result of all previous layers.

Example (left: key, right: value):

  DiffColor0     - gray
  DiffTextureOp0 - aiTextureOpMultiply
  DiffTexture0   - tex1.png
  DiffTextureOp0 - aiTextureOpAdd
  DiffTexture1   - tex2.png

Written as equation, the final diffuse term for a specific pixel would be:

  diffFinal = DiffColor0 * sampleTex(DiffTexture0,UV0) +
     sampleTex(DiffTexture1,UV0) * diffContrib;

where 'diffContrib' is the intensity of the incoming light for that pixel.

Enumerator:
aiTextureOp_Multiply

T = T1 * T2.

aiTextureOp_Add

T = T1 + T2.

aiTextureOp_Subtract

T = T1 - T2.

aiTextureOp_Divide

T = T1 / T2.

aiTextureOp_SmoothAdd

T = (T1 + T2) - (T1 * T2)

aiTextureOp_SignedAdd

T = T1 + (T2-0.5)

enum aiTextureType

Defines the purpose of a texture.

This is a very difficult topic. Different 3D packages support different kinds of textures. For very common texture types, such as bumpmaps, the rendering results depend on implementation details in the rendering pipelines of these applications. Assimp loads all texture references from the model file and tries to determine which of the predefined texture types below is the best choice to match the original use of the texture as closely as possible.

In content pipelines you'll usually define how textures have to be handled, and the artists working on models have to conform to this specification, regardless which 3D tool they're using.

Enumerator:
aiTextureType_NONE

Dummy value.

No texture, but the value to be used as 'texture semantic' (#aiMaterialProperty::mSemantic) for all material properties *not* related to textures.

aiTextureType_DIFFUSE

The texture is combined with the result of the diffuse lighting equation.

aiTextureType_SPECULAR

The texture is combined with the result of the specular lighting equation.

aiTextureType_AMBIENT

The texture is combined with the result of the ambient lighting equation.

aiTextureType_EMISSIVE

The texture is added to the result of the lighting calculation.

It isn't influenced by incoming light.

aiTextureType_HEIGHT

The texture is a height map.

By convention, higher gray-scale values stand for higher elevations from the base height.

aiTextureType_NORMALS

The texture is a (tangent space) normal-map.

Again, there are several conventions for tangent-space normal maps. Assimp does (intentionally) not distinguish here.

aiTextureType_SHININESS

The texture defines the glossiness of the material.

The glossiness is in fact the exponent of the specular (phong) lighting equation. Usually there is a conversion function defined to map the linear color values in the texture to a suitable exponent. Have fun.

aiTextureType_OPACITY

The texture defines per-pixel opacity.

Usually 'white' means opaque and 'black' means 'transparency'. Or quite the opposite. Have fun.

aiTextureType_DISPLACEMENT

Displacement texture.

The exact purpose and format is application-dependent. Higher color values stand for higher vertex displacements.

aiTextureType_LIGHTMAP

Lightmap texture (aka Ambient Occlusion)

Both 'Lightmaps' and dedicated 'ambient occlusion maps' are covered by this material property. The texture contains a scaling value for the final color value of a pixel. Its intensity is not affected by incoming light.

aiTextureType_REFLECTION

Reflection texture.

Contains the color of a perfect mirror reflection. Rarely used, almost never for real-time applications.

aiTextureType_UNKNOWN

Unknown texture.

A texture reference that does not match any of the definitions above is considered to be 'unknown'. It is still imported, but is excluded from any further postprocessing.

Variable Documentation

struct aiUVTransform PACK_STRUCT


Assimp: material.inl File Reference

  • File List
  • File Members
Defines
material.inl File Reference

Defines

#define AI_MATERIAL_INL_INC

Define Documentation

#define AI_MATERIAL_INL_INC


Assimp: matrix3x3.h File Reference

  • File List
  • File Members
Classes | Typedefs | Variables
matrix3x3.h File Reference

Definition of a 3x3 matrix, including operators when compiling in C++. More...

Classes

class | aiMatrix3x3t< TReal >
Represents a row-major 3x3 matrix. More...

Typedefs

typedef aiMatrix3x3t< float > | aiMatrix3x3

Variables

class aiMatrix3x3t | PACK_STRUCT

Detailed Description

Definition of a 3x3 matrix, including operators when compiling in C++.

Typedef Documentation

typedef aiMatrix3x3t<float> aiMatrix3x3

Variable Documentation

class aiMatrix3x3t PACK_STRUCT


Assimp: matrix3x3.inl File Reference

  • File List
  • File Members
Defines
matrix3x3.inl File Reference

Defines

#define AI_MATRIX3x3_INL_INC

Define Documentation

#define AI_MATRIX3x3_INL_INC


Assimp: matrix4x4.h File Reference

  • File List
  • File Members
Classes | Typedefs | Variables
matrix4x4.h File Reference

4x4 matrix structure, including operators when compiling in C++ More...

Classes

class | aiMatrix4x4t< TReal >
Represents a row-major 4x4 matrix, use this for homogeneous coordinates. More...

Typedefs

typedef aiMatrix4x4t< float > | aiMatrix4x4

Variables

class aiMatrix4x4t | PACK_STRUCT

Detailed Description

4x4 matrix structure, including operators when compiling in C++

Typedef Documentation

typedef aiMatrix4x4t<float> aiMatrix4x4

Variable Documentation

class aiMatrix4x4t PACK_STRUCT


Assimp: matrix4x4.inl File Reference

  • File List
  • File Members
Defines
matrix4x4.inl File Reference

Defines

#define AI_MATRIX4x4_INL_INC

Define Documentation

#define AI_MATRIX4x4_INL_INC


Assimp: mesh.h File Reference

  • File List
  • File Members
Classes | Defines | Enumerations
mesh.h File Reference

Declares the data structures in which the imported geometry is returned by ASSIMP: aiMesh, aiFace and aiBone data structures. More...

Classes

struct | aiAnimMesh
NOT CURRENTLY IN USE. More...
struct | aiBone
A single bone of a mesh. More...
struct | aiFace
A single face in a mesh, referring to multiple vertices. More...
struct | aiMesh
A mesh represents a geometry or model with a single material. More...
struct | aiVertexWeight
A single influence of a bone on a vertex. More...

Defines

#define | AI_MAX_BONE_WEIGHTS 0x7fffffff
Maximum number of indices per face (polygon).
#define | AI_MAX_FACE_INDICES 0x7fff
Maximum number of indices per face (polygon).
#define | AI_MAX_FACES 0x7fffffff
Maximum number of faces per mesh.
#define | AI_MAX_NUMBER_OF_COLOR_SETS 0x8
Supported number of vertex color sets per mesh.
#define | AI_MAX_NUMBER_OF_TEXTURECOORDS 0x8
Supported number of texture coord sets (UV(W) channels) per mesh.
#define | AI_MAX_VERTICES 0x7fffffff
Maximum number of vertices per mesh.
#define | AI_PRIMITIVE_TYPE_FOR_N_INDICES(n) ((n) > 3 ? aiPrimitiveType_POLYGON : (aiPrimitiveType)(1u << ((n)-1)))
enum aiPrimitiveType

Enumerations

enum aiPrimitiveType {
aiPrimitiveType_POINT = 0x1, aiPrimitiveType_LINE = 0x2, aiPrimitiveType_TRIANGLE = 0x4, aiPrimitiveType_POLYGON = 0x8,
_aiPrimitiveType_Force32Bit = 0x9fffffff
}
Enumerates the types of geometric primitives supported by Assimp. More...

Detailed Description

Declares the data structures in which the imported geometry is returned by ASSIMP: aiMesh, aiFace and aiBone data structures.

Define Documentation

#define AI_MAX_BONE_WEIGHTS 0x7fffffff

Maximum number of indices per face (polygon).

#define AI_MAX_FACE_INDICES 0x7fff

Maximum number of indices per face (polygon).

#define AI_MAX_FACES 0x7fffffff

Maximum number of faces per mesh.

#define AI_MAX_NUMBER_OF_COLOR_SETS 0x8

Supported number of vertex color sets per mesh.

#define AI_MAX_NUMBER_OF_TEXTURECOORDS 0x8

Supported number of texture coord sets (UV(W) channels) per mesh.

#define AI_MAX_VERTICES 0x7fffffff

Maximum number of vertices per mesh.

#define AI_PRIMITIVE_TYPE_FOR_N_INDICES ( n ) ((n) > 3 ? aiPrimitiveType_POLYGON : (aiPrimitiveType)(1u << ((n)-1)))

enum aiPrimitiveType

Enumeration Type Documentation

enum aiPrimitiveType

Enumerates the types of geometric primitives supported by Assimp.

See also:
aiFace Face data structure
aiProcess_SortByPType Per-primitive sorting of meshes
aiProcess_Triangulate Automatic triangulation
AI_CONFIG_PP_SBP_REMOVE Removal of specific primitive types.
Enumerator:
aiPrimitiveType_POINT

A point primitive.

This is just a single vertex in the virtual world, aiFace contains just one index for such a primitive.

aiPrimitiveType_LINE

A line primitive.

This is a line defined through a start and an end position. aiFace contains exactly two indices for such a primitive.

aiPrimitiveType_TRIANGLE

A triangular primitive.

A triangle consists of three indices.

aiPrimitiveType_POLYGON

A higher-level polygon with more than 3 edges.

A triangle is a polygon, but polygon in this context means "all polygons that are not triangles". The "Triangulate"-Step is provided for your convenience, it splits all polygons in triangles (which are much easier to handle).

_aiPrimitiveType_Force32Bit

This value is not used.

It is just here to force the compiler to map this enum to a 32 Bit integer.


Assimp: NullLogger.hpp File Reference

  • File List
  • File Members
Classes | Namespaces
NullLogger.hpp File Reference

Classes

class | Assimp::NullLogger
CPP-API: Empty logging implementation. More...

Namespaces

namespace | Assimp

Assimp's CPP-API and all internal APIs.


Assimp: poppack1.h File Reference

  • File List
  • File Members
poppack1.h File Reference


Assimp: postprocess.h File Reference

  • File List
  • File Members
Defines | Enumerations
postprocess.h File Reference

Definitions for import post processing steps. More...

Defines

#define | aiProcess_ConvertToLeftHanded
Shortcut flag for Direct3D-based applications.
#define | aiProcessPreset_TargetRealtime_Fast
#define | aiProcessPreset_TargetRealtime_MaxQuality
Default postprocess configuration optimizing the data for real-time rendering.
#define | aiProcessPreset_TargetRealtime_Quality
Default postprocess configuration optimizing the data for real-time rendering.

Enumerations

enum aiPostProcessSteps {
aiProcess_CalcTangentSpace = 0x1, aiProcess_JoinIdenticalVertices = 0x2, aiProcess_MakeLeftHanded = 0x4, aiProcess_Triangulate = 0x8,
aiProcess_RemoveComponent = 0x10, aiProcess_GenNormals = 0x20, aiProcess_GenSmoothNormals = 0x40, aiProcess_SplitLargeMeshes = 0x80,
aiProcess_PreTransformVertices = 0x100, aiProcess_LimitBoneWeights = 0x200, aiProcess_ValidateDataStructure = 0x400, aiProcess_ImproveCacheLocality = 0x800,
aiProcess_RemoveRedundantMaterials = 0x1000, aiProcess_FixInfacingNormals = 0x2000, aiProcess_SortByPType = 0x8000, aiProcess_FindDegenerates = 0x10000,
aiProcess_FindInvalidData = 0x20000, aiProcess_GenUVCoords = 0x40000, aiProcess_TransformUVCoords = 0x80000, aiProcess_FindInstances = 0x100000,
aiProcess_OptimizeMeshes = 0x200000, aiProcess_OptimizeGraph = 0x400000, aiProcess_FlipUVs = 0x800000, aiProcess_FlipWindingOrder = 0x1000000,
aiProcess_SplitByBoneCount = 0x2000000, aiProcess_Debone = 0x4000000
}
Defines the flags for all possible post processing steps. More...

Detailed Description

Definitions for import post processing steps.

Define Documentation

#define aiProcess_ConvertToLeftHanded
Value:
( \
        aiProcess_MakeLeftHanded     | \
        aiProcess_FlipUVs            | \
        aiProcess_FlipWindingOrder   | \
        0 )

Shortcut flag for Direct3D-based applications.

Supersedes the aiProcess_MakeLeftHanded and aiProcess_FlipUVs and aiProcess_FlipWindingOrder flags. The output data matches Direct3D's conventions: left-handed geometry, upper-left origin for UV coordinates and finally clockwise face order, suitable for CCW culling.

Deprecated:
#define aiProcessPreset_TargetRealtime_Fast
Value:
( \
        aiProcess_CalcTangentSpace              |  \
        aiProcess_GenNormals                    |  \
        aiProcess_JoinIdenticalVertices |  \
        aiProcess_Triangulate                   |  \
        aiProcess_GenUVCoords           |  \
        aiProcess_SortByPType           |  \
        0 )
#define aiProcessPreset_TargetRealtime_MaxQuality
Value:
( \
        aiProcessPreset_TargetRealtime_Quality   |  \
        aiProcess_FindInstances                  |  \
        aiProcess_ValidateDataStructure          |  \
        aiProcess_OptimizeMeshes                 |  \
        aiProcess_Debone                                                 |  \
        0 )

Default postprocess configuration optimizing the data for real-time rendering.

This preset enables almost every optimization step to achieve perfectly optimized data. It's your choice for level editor environments where import speed is not important.

If you're using DirectX, don't forget to combine this value with the aiProcess_ConvertToLeftHanded step. If you don't support UV transformations in your application, apply the aiProcess_TransformUVCoords step, too.

Note:
Please take the time to read the docs for the steps enabled by this preset. Some of them offer further configurable properties, while some of them might not be of use for you so it might be better to not specify them.
#define aiProcessPreset_TargetRealtime_Quality
Value:
( \
        aiProcess_CalcTangentSpace                              |  \
        aiProcess_GenSmoothNormals                              |  \
        aiProcess_JoinIdenticalVertices                 |  \
        aiProcess_ImproveCacheLocality                  |  \
        aiProcess_LimitBoneWeights                              |  \
        aiProcess_RemoveRedundantMaterials      |  \
        aiProcess_SplitLargeMeshes                              |  \
        aiProcess_Triangulate                                   |  \
        aiProcess_GenUVCoords                   |  \
        aiProcess_SortByPType                   |  \
        aiProcess_FindDegenerates               |  \
        aiProcess_FindInvalidData               |  \
        0 )

Default postprocess configuration optimizing the data for real-time rendering.

Unlike aiProcessPreset_TargetRealtime_Fast, this configuration performs some extra optimizations to improve rendering speed and to minimize memory usage. It could be a good choice for a level editor environment where import speed is not so important.

If you're using DirectX, don't forget to combine this value with the aiProcess_ConvertToLeftHanded step. If you don't support UV transformations in your application apply the aiProcess_TransformUVCoords step, too.

Note:
Please take the time to read the docs for the steps enabled by this preset. Some of them offer further configurable properties, while some of them might not be of use for you so it might be better to not specify them.

Enumeration Type Documentation

enum aiPostProcessSteps

Defines the flags for all possible post processing steps.

See also:
Importer::ReadFile
aiImportFile
aiImportFileEx
Enumerator:
aiProcess_CalcTangentSpace
Calculates the tangents and bitangents for the imported meshes.

Does nothing if a mesh does not have normals. You might want this post processing step to be executed if you plan to use tangent space calculations such as normal mapping applied to the meshes. There's a config setting, AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE, which allows you to specify a maximum smoothing angle for the algorithm. However, usually you'll want to leave it at the default value.

aiProcess_JoinIdenticalVertices
Identifies and joins identical vertex data sets within all imported meshes.

After this step is run, each mesh contains unique vertices, so a vertex may be used by multiple faces. You usually want to use this post processing step. If your application deals with indexed geometry, this step is compulsory or you'll just waste rendering time. If this flag is not specified, no vertices are referenced by more than one face and no index buffer is required for rendering.

aiProcess_MakeLeftHanded
Converts all the imported data to a left-handed coordinate space.

By default the data is returned in a right-handed coordinate space (which OpenGL prefers). In this space, +X points to the right, +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 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_Triangulate
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:

  • Specify both aiProcess_Triangulate and aiProcess_SortByPType Ignore all point and line meshes when you process assimp's output
aiProcess_RemoveComponent
Removes some parts of the data structure (animations, materials, light sources, cameras, textures, vertex components).

The components to be removed are specified in a separate configuration option, AI_CONFIG_PP_RVC_FLAGS. 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_GenNormals
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_GenSmoothNormals
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 configuration option, AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE 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_SplitLargeMeshes
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 AI_CONFIG_PP_SLM_VERTEX_LIMIT and AI_CONFIG_PP_SLM_TRIANGLE_LIMIT settings. The default values are AI_SLM_DEFAULT_MAX_VERTICES and AI_SLM_DEFAULT_MAX_TRIANGLES.

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_PreTransformVertices
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 AI_CONFIG_PP_PTV_NORMALIZE configuration property can be set to normalize the scene's spatial dimension to the -1...1 range.
aiProcess_LimitBoneWeights
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 AI_LMW_MAX_WEIGHTS in config.h), but you can use the AI_CONFIG_PP_LBW_MAX_WEIGHTS setting to supply your own limit to the post processing step.

If you intend to perform the skinning in hardware, this post processing step might be of interest to you.

aiProcess_ValidateDataStructure
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:

  • 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.
  • 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, #AI_SCENE_FLAGS_VALIDATION_WARNING is set in aiScene::mFlags

This post-processing step is not time-consuming. Its use is not compulsory, but recommended.

aiProcess_ImproveCacheLocality
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 this paper).

If you intend to render huge models in hardware, this step might be of interest to you. The AI_CONFIG_PP_ICL_PTCACHE_SIZEconfig setting can be used to fine-tune the cache optimization.

aiProcess_RemoveRedundantMaterials
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 AI_CONFIG_PP_RRM_EXCLUDE_LIST setting.

aiProcess_FixInfacingNormals
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_SortByPType
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 AI_CONFIG_PP_SBP_REMOVE option to specify which primitive types you need. This can be used to easily exclude lines and points, which are rarely used, from the import.

aiProcess_FindDegenerates
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:
1. (if you support lines and points for rendering but don't want the degenerates)

  • Specify the aiProcess_FindDegenerates flag.
  • Set the AI_CONFIG_PP_FD_REMOVE option 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.

2.(if you don't support lines and points at all)

  • Specify the aiProcess_FindDegenerates flag.
  • Specify the aiProcess_SortByPType flag. This moves line and point primitives to separate meshes.
  • Set the AI_CONFIG_PP_SBP_REMOVE option to
     aiPrimitiveType_POINTS | aiPrimitiveType_LINES
    to cause SortByPType to reject point and line meshes from the scene.
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_FindInvalidData
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.
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 AI_CONFIG_PP_FID_ANIM_ACCURACY config property decides the accuracy of the check for duplicate animation tracks.

aiProcess_GenUVCoords
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 AI_MATKEY_MAPPING material property in order to display all assets properly.
aiProcess_TransformUVCoords
This step applies per-texture UV transformations and bakes them into stand-alone vtexture coordinate channels.

UV transformations are specified per-texture - see the AI_MATKEY_UVTRANSFORM 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_FindInstances
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_OptimizeMeshes
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_OptimizeGraph
A postprocessing step to optimize the scene hierarchy.

Nodes without animations, bones, lights or cameras assigned are collapsed and joined.

Node names can be lost during this step. If you use special 'tag nodes' to pass additional information through your content pipeline, use the AI_CONFIG_PP_OG_EXCLUDE_LIST setting to specify a list of node names you want to be kept. Nodes matching one of the names in this list won't be touched or modified.

Use this flag with caution. Most simple files will be collapsed to a single node, so complex hierarchies are usually completely lost. This is not useful for editor environments, but probably a very effective optimization if you just want to get the model data, convert it to your own format, and render it as fast as possible.

This flag is designed to be used with aiProcess_OptimizeMeshes for best results.

Note:
'Crappy' scenes with thousands of extremely small meshes packed in deeply nested nodes exist for almost all file formats. aiProcess_OptimizeMeshes in combination with aiProcess_OptimizeGraph usually fixes them all and makes them renderable.
aiProcess_FlipUVs
This step flips all UV coordinates along the y-axis and adjusts material settings and bitangents accordingly.

Output UV coordinate system:

 0y|0y ---------- 1x|0y
 |                 |
 |                 |
 |                 |
 0x|1y ---------- 1x|1y

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_FlipWindingOrder
This step adjusts the output face winding order to be CW.

The default face winding order is counter clockwise (CCW).

Output face order:

       x2

                         x0
  x1
aiProcess_SplitByBoneCount
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_Debone
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 AI_CONFIG_PP_DB_THRESHOLD to control this. Use AI_CONFIG_PP_DB_ALL_OR_NONE if you want bones removed if and only if all bones within the scene qualify for removal.


Assimp: ProgressHandler.hpp File Reference

  • File List
  • File Members
Classes | Namespaces
ProgressHandler.hpp File Reference

Classes

class | Assimp::ProgressHandler
CPP-API: Abstract interface for custom progress report receivers. More...

Namespaces

namespace | Assimp

Assimp's CPP-API and all internal APIs.


Assimp: pushpack1.h File Reference

  • File List
  • File Members
Defines
pushpack1.h File Reference

Defines

#define AI_PUSHPACK_IS_DEFINED

Define Documentation

#define AI_PUSHPACK_IS_DEFINED


Assimp: quaternion.h File Reference

  • File List
  • File Members
Classes | Typedefs
quaternion.h File Reference

Quaternion structure, including operators when compiling in C++. More...

Classes

class | aiQuaterniont< TReal >
Represents a quaternion in a 4D vector. More...

Typedefs

typedef aiQuaterniont< float > | aiQuaternion

Detailed Description

Quaternion structure, including operators when compiling in C++.

Typedef Documentation

typedef aiQuaterniont<float> aiQuaternion


Assimp: quaternion.inl File Reference

  • File List
  • File Members
Defines
quaternion.inl File Reference

Defines

#define AI_QUATERNION_INL_INC

Define Documentation

#define AI_QUATERNION_INL_INC


Assimp: scene.h File Reference

  • File List
  • File Members
Classes
scene.h File Reference

Classes

struct | aiNode
A node in the imported hierarchy. More...
struct | aiScene
The root structure of the imported data. More...


Assimp: texture.h File Reference

  • File List
  • File Members
Classes | Defines | Variables
texture.h File Reference

Defines texture helper structures for the library. More...

Classes

struct | aiTexel
Helper structure to represent a texel in a ARGB8888 format. More...
struct | aiTexture
Helper structure to describe an embedded texture. More...

Defines

#define | AI_MAKE_EMBEDDED_TEXNAME(_n_) "*" # _n_
Used to build the reserved path name used by the material system to reference textures that are embedded into their corresponding model files.

Variables

struct aiTexel | PACK_STRUCT

Detailed Description

Defines texture helper structures for the library.

Used for file formats which embed their textures into the model file. Supported are both normal textures, which are stored as uncompressed pixels, and "compressed" textures, which are stored in a file format such as PNG or TGA.

Define Documentation

#define AI_MAKE_EMBEDDED_TEXNAME ( _n_ ) "*" # _n_

Used to build the reserved path name used by the material system to reference textures that are embedded into their corresponding model files.

The parameter specifies the index of the texture (zero-based, in the aiScene::mTextures array)

Variable Documentation

struct aiTexel PACK_STRUCT


Assimp: types.h File Reference

  • File List
  • File Members
Classes | Namespaces | Variables
types.h File Reference

Basic data types and primitives, such as vectors or colors. More...

Classes

struct | aiColor3D
Represents a color in Red-Green-Blue space. More...
struct | aiPlane
Represents a plane in a three-dimensional, euclidean space. More...
struct | aiRay
Represents a ray. More...
struct | aiString
Represents an UTF-8 string, zero byte terminated. More...

Namespaces

namespace | Assimp

Assimp's CPP-API and all internal APIs.

Variables

const size_t | MAXLEN = 1024
Maximum dimension for strings, ASSIMP strings are zero terminated.
struct aiPlane | PACK_STRUCT

Detailed Description

Basic data types and primitives, such as vectors or colors.

Variable Documentation

const size_t MAXLEN = 1024

Maximum dimension for strings, ASSIMP strings are zero terminated.

struct aiColor3D PACK_STRUCT


Assimp: vector2.h File Reference

  • File List
  • File Members
Classes | Typedefs | Variables
vector2.h File Reference

Classes

class | aiVector2t< TReal >
Represents a two-dimensional vector. More...

Typedefs

typedef aiVector2t< float > | aiVector2D

Variables

class aiVector2t | PACK_STRUCT

Typedef Documentation

typedef aiVector2t<float> aiVector2D

Variable Documentation

class aiVector2t PACK_STRUCT


Assimp: vector2.inl File Reference

  • File List
  • File Members
Defines | Functions
vector2.inl File Reference

Defines

#define | AI_VECTOR2D_INL_INC

Functions

template<typename TReal >
TReal | operator* (const aiVector2t< TReal > &v1, const aiVector2t< TReal > &v2)
template<typename TReal >
aiVector2t< TReal > | operator* (TReal f, const aiVector2t< TReal > &v)
template<typename TReal >
aiVector2t< TReal > | operator* (const aiVector2t< TReal > &v, TReal f)
template<typename TReal >
aiVector2t< TReal > | operator+ (const aiVector2t< TReal > &v1, const aiVector2t< TReal > &v2)
template<typename TReal >
aiVector2t< TReal > | operator- (const aiVector2t< TReal > &v)
template<typename TReal >
aiVector2t< TReal > | operator- (const aiVector2t< TReal > &v1, const aiVector2t< TReal > &v2)
template<typename TReal >
aiVector2t< TReal > | operator/ (const aiVector2t< TReal > &v, TReal f)
template<typename TReal >
aiVector2t< TReal > | operator/ (const aiVector2t< TReal > &v, const aiVector2t< TReal > &v2)

Define Documentation

#define AI_VECTOR2D_INL_INC

Function Documentation

template<typename TReal >
TReal operator* | ( | const aiVector2t< TReal > & | v1,
 |  | const aiVector2t< TReal > & | v2
 | ) |  | [inline]
template<typename TReal >
aiVector2t<TReal> operator* | ( | TReal | f,
 |  | const aiVector2t< TReal > & | v
 | ) |  | [inline]
template<typename TReal >
aiVector2t<TReal> operator* | ( | const aiVector2t< TReal > & | v,
 |  | TReal | f
 | ) |  | [inline]
template<typename TReal >
aiVector2t<TReal> operator+ | ( | const aiVector2t< TReal > & | v1,
 |  | const aiVector2t< TReal > & | v2
 | ) |  | [inline]
template<typename TReal >
aiVector2t<TReal> operator- ( const aiVector2t< TReal > & v ) [inline]
template<typename TReal >
aiVector2t<TReal> operator- | ( | const aiVector2t< TReal > & | v1,
 |  | const aiVector2t< TReal > & | v2
 | ) |  | [inline]
template<typename TReal >
aiVector2t<TReal> operator/ | ( | const aiVector2t< TReal > & | v,
 |  | TReal | f
 | ) |  | [inline]
template<typename TReal >
aiVector2t<TReal> operator/ | ( | const aiVector2t< TReal > & | v,
 |  | const aiVector2t< TReal > & | v2
 | ) |  | [inline]


Assimp: vector3.h File Reference

  • File List
  • File Members
Classes | Typedefs | Variables
vector3.h File Reference

Classes

class | aiVector3t< TReal >
Represents a three-dimensional vector. More...

Typedefs

typedef aiVector3t< float > | aiVector3D

Variables

class aiVector3t | PACK_STRUCT

Typedef Documentation

typedef aiVector3t<float> aiVector3D

Variable Documentation

class aiVector3t PACK_STRUCT


Assimp: vector3.inl File Reference

  • File List
  • File Members
Defines | Functions
vector3.inl File Reference

Defines

#define | AI_VECTOR3D_INL_INC

Functions

template<typename TReal >
aiVector3t< TReal > | operator* (const aiMatrix3x3t< TReal > &pMatrix, const aiVector3t< TReal > &pVector)
Transformation of a vector by a 3x3 matrix.
template<typename TReal >
aiVector3t< TReal > | operator* (const aiMatrix4x4t< TReal > &pMatrix, const aiVector3t< TReal > &pVector)
Transformation of a vector by a 4x4 matrix.
template<typename TReal >
AI_FORCE_INLINE TReal | operator* (const aiVector3t< TReal > &v1, const aiVector3t< TReal > &v2)
template<typename TReal >
AI_FORCE_INLINE aiVector3t< TReal > | operator* (TReal f, const aiVector3t< TReal > &v)
template<typename TReal >
AI_FORCE_INLINE aiVector3t< TReal > | operator* (const aiVector3t< TReal > &v, TReal f)
template<typename TReal >
AI_FORCE_INLINE aiVector3t< TReal > | operator+ (const aiVector3t< TReal > &v1, const aiVector3t< TReal > &v2)
template<typename TReal >
AI_FORCE_INLINE aiVector3t< TReal > | operator- (const aiVector3t< TReal > &v1, const aiVector3t< TReal > &v2)
template<typename TReal >
AI_FORCE_INLINE aiVector3t< TReal > | operator- (const aiVector3t< TReal > &v)
template<typename TReal >
AI_FORCE_INLINE aiVector3t< TReal > | operator/ (const aiVector3t< TReal > &v, TReal f)
template<typename TReal >
AI_FORCE_INLINE aiVector3t< TReal > | operator/ (const aiVector3t< TReal > &v, const aiVector3t< TReal > &v2)
template<typename TReal >
AI_FORCE_INLINE aiVector3t< TReal > | operator^ (const aiVector3t< TReal > &v1, const aiVector3t< TReal > &v2)

Define Documentation

#define AI_VECTOR3D_INL_INC

Function Documentation

template<typename TReal >
aiVector3t<TReal> operator* | ( | const aiMatrix3x3t< TReal > & | pMatrix,
 |  | const aiVector3t< TReal > & | pVector
 | ) |  | [inline]

Transformation of a vector by a 3x3 matrix.

template<typename TReal >
aiVector3t<TReal> operator* | ( | const aiMatrix4x4t< TReal > & | pMatrix,
 |  | const aiVector3t< TReal > & | pVector
 | ) |  | [inline]

Transformation of a vector by a 4x4 matrix.

template<typename TReal >
AI_FORCE_INLINE TReal operator* | ( | const aiVector3t< TReal > & | v1,
 |  | const aiVector3t< TReal > & | v2
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiVector3t<TReal> operator* | ( | TReal | f,
 |  | const aiVector3t< TReal > & | v
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiVector3t<TReal> operator* | ( | const aiVector3t< TReal > & | v,
 |  | TReal | f
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiVector3t<TReal> operator+ | ( | const aiVector3t< TReal > & | v1,
 |  | const aiVector3t< TReal > & | v2
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiVector3t<TReal> operator- | ( | const aiVector3t< TReal > & | v1,
 |  | const aiVector3t< TReal > & | v2
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiVector3t<TReal> operator- ( const aiVector3t< TReal > & v )
template<typename TReal >
AI_FORCE_INLINE aiVector3t<TReal> operator/ | ( | const aiVector3t< TReal > & | v,
 |  | TReal | f
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiVector3t<TReal> operator/ | ( | const aiVector3t< TReal > & | v,
 |  | const aiVector3t< TReal > & | v2
 | ) |  |
template<typename TReal >
AI_FORCE_INLINE aiVector3t<TReal> operator^ | ( | const aiVector3t< TReal > & | v1,
 |  | const aiVector3t< TReal > & | v2
 | ) |  |


Assimp: version.h File Reference

  • File List
  • File Members
Defines | Functions
version.h File Reference

Defines

#define | ASSIMP_CFLAGS_DEBUG 0x4
Assimp was compiled as a debug build.
#define | ASSIMP_CFLAGS_NOBOOST 0x8
Assimp was compiled with ASSIMP_BUILD_BOOST_WORKAROUND defined.
#define | ASSIMP_CFLAGS_SHARED 0x1
Assimp was compiled as a shared object (Windows: DLL)
#define | ASSIMP_CFLAGS_SINGLETHREADED 0x10
Assimp was compiled with ASSIMP_BUILD_SINGLETHREADED defined.
#define | ASSIMP_CFLAGS_STLPORT 0x2
Assimp was compiled against STLport.

Functions

ASSIMP_API unsigned int | aiGetCompileFlags (void)
Returns assimp's compile flags.
ASSIMP_API const char * | aiGetLegalString (void)
Returns a string with legal copyright and licensing information about Assimp.
ASSIMP_API unsigned int | aiGetVersionMajor (void)
Returns the current major version number of Assimp.
ASSIMP_API unsigned int | aiGetVersionMinor (void)
Returns the current minor version number of Assimp.
ASSIMP_API unsigned int | aiGetVersionRevision (void)
Returns the repository revision of the Assimp runtime.

Define Documentation

#define ASSIMP_CFLAGS_DEBUG 0x4

Assimp was compiled as a debug build.

#define ASSIMP_CFLAGS_NOBOOST 0x8

Assimp was compiled with ASSIMP_BUILD_BOOST_WORKAROUND defined.

#define ASSIMP_CFLAGS_SHARED 0x1

Assimp was compiled as a shared object (Windows: DLL)

#define ASSIMP_CFLAGS_SINGLETHREADED 0x10

Assimp was compiled with ASSIMP_BUILD_SINGLETHREADED defined.

#define ASSIMP_CFLAGS_STLPORT 0x2

Assimp was compiled against STLport.

Function Documentation

ASSIMP_API unsigned int aiGetCompileFlags ( void )

Returns assimp's compile flags.

Returns:
Any bitwise combination of the ASSIMP_CFLAGS_xxx constants.
ASSIMP_API const char* aiGetLegalString ( void )

Returns a string with legal copyright and licensing information about Assimp.

The string may include multiple lines.

Returns:
Pointer to static string.
ASSIMP_API unsigned int aiGetVersionMajor ( void )

Returns the current major version number of Assimp.

Returns:
Major version of the Assimp runtime the application was linked/built against
ASSIMP_API unsigned int aiGetVersionMinor ( void )

Returns the current minor version number of Assimp.

Returns:
Minor version of the Assimp runtime the application was linked/built against
ASSIMP_API unsigned int aiGetVersionRevision ( void )

Returns the repository revision of the Assimp runtime.

Returns:
SVN Repository revision number of the Assimp runtime the application was linked/built against


Assimp: File Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • c
  • m
  • o
  • p
Here is a list of all file members with links to the files they belong to:

- _ -

  • _aiAnimBehaviour_Force32Bit : anim.h
  • _aiComponent_Force32Bit : config.h
  • _aiLightSource_Force32Bit : light.h
  • _aiPrimitiveType_Force32Bit : mesh.h


Assimp: Member List

  • Assimp
  • BaseImporter
Assimp::BaseImporter Member List
This is the complete list of members for Assimp::BaseImporter, including all inherited members.
BaseImporter() | Assimp::BaseImporter |
CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const =0 | Assimp::BaseImporter | [pure virtual]
CheckMagicToken(IOSystem *pIOHandler, const std::string &pFile, const void *magic, unsigned int num, unsigned int offset=0, unsigned int size=4) | Assimp::BaseImporter | [static]
ConvertToUTF8(std::vector< char > &data) | Assimp::BaseImporter | [static]
GetErrorText() const | Assimp::BaseImporter | [inline]
GetExtension(const std::string &pFile) | Assimp::BaseImporter | [static]
GetExtensionList(std::set< std::string > &extensions) | Assimp::BaseImporter |
GetInfo() const =0 | Assimp::BaseImporter | [pure virtual]
Importer class | Assimp::BaseImporter | [friend]
InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler)=0 | Assimp::BaseImporter | [protected, pure virtual]
mErrorText | Assimp::BaseImporter | [protected]
progress | Assimp::BaseImporter | [protected]
ReadFile(const Importer *pImp, const std::string &pFile, IOSystem *pIOHandler) | Assimp::BaseImporter |
SearchFileHeaderForToken(IOSystem *pIOSystem, const std::string &file, const char **tokens, unsigned int numTokens, unsigned int searchBytes=200, bool tokensSol=false) | Assimp::BaseImporter | [static]
SetupProperties(const Importer *pImp) | Assimp::BaseImporter | [virtual]
SimpleExtensionCheck(const std::string &pFile, const char *ext0, const char *ext1=NULL, const char *ext2=NULL) | Assimp::BaseImporter | [static]
TextFileToBuffer(IOStream *stream, std::vector< char > &data) | Assimp::BaseImporter | [static]
~BaseImporter() | Assimp::BaseImporter | [virtual]


Assimp: Member List

  • Assimp
  • DefaultLogger
Assimp::DefaultLogger Member List
This is the complete list of members for Assimp::DefaultLogger, including all inherited members.
attachStream(LogStream *pStream, unsigned int severity) | Assimp::DefaultLogger | [virtual]
create(const char *name=ASSIMP_DEFAULT_LOG_NAME, LogSeverity severity=NORMAL, unsigned int defStreams=aiDefaultLogStream_DEBUGGER|aiDefaultLogStream_FILE, IOSystem *io=NULL) | Assimp::DefaultLogger | [static]
debug(const char *message) | Assimp::Logger |
debug(const std::string &message) | Assimp::Logger | [inline]
Debugging enum value | Assimp::Logger |
detatchStream(LogStream *pStream, unsigned int severity) | Assimp::DefaultLogger | [virtual]
Err enum value | Assimp::Logger |
error(const char *message) | Assimp::Logger |
error(const std::string &message) | Assimp::Logger | [inline]
ErrorSeverity enum name | Assimp::Logger |
get() | Assimp::DefaultLogger | [static]
getLogSeverity() const | Assimp::Logger | [inline]
info(const char *message) | Assimp::Logger |
info(const std::string &message) | Assimp::Logger | [inline]
Info enum value | Assimp::Logger |
isNullLogger() | Assimp::DefaultLogger | [static]
kill() | Assimp::DefaultLogger | [static]
Logger() | Assimp::Logger | [inline, protected]
Logger(LogSeverity severity) | Assimp::Logger | [inline, protected]
LogSeverity enum name | Assimp::Logger |
m_Severity | Assimp::Logger | [protected]
NORMAL enum value | Assimp::Logger |
set(Logger *logger) | Assimp::DefaultLogger | [static]
setLogSeverity(LogSeverity log_severity) | Assimp::Logger | [inline]
VERBOSE enum value | Assimp::Logger |
warn(const char *message) | Assimp::Logger |
warn(const std::string &message) | Assimp::Logger | [inline]
Warn enum value | Assimp::Logger |
~Logger() | Assimp::Logger | [inline, virtual]


Assimp: Member List

  • Assimp
  • Exporter
Assimp::Exporter Member List
This is the complete list of members for Assimp::Exporter, including all inherited members.
Export(const aiScene *pScene, const char *pFormatId, const char *pPath, unsigned int pPreprocessing=0u) | Assimp::Exporter |
Export(const aiScene *pScene, const std::string &pFormatId, const std::string &pPath, unsigned int pPreprocessing=0u) | Assimp::Exporter | [inline]
Exporter() | Assimp::Exporter |
ExportToBlob(const aiScene *pScene, const char *pFormatId, unsigned int pPreprocessing=0u) | Assimp::Exporter |
ExportToBlob(const aiScene *pScene, const std::string &pFormatId, unsigned int pPreprocessing=0u) | Assimp::Exporter | [inline]
fpExportFunc typedef | Assimp::Exporter |
FreeBlob() | Assimp::Exporter |
GetBlob() const | Assimp::Exporter |
GetErrorString() const | Assimp::Exporter |
GetExportFormatCount() const | Assimp::Exporter |
GetExportFormatDescription(size_t pIndex) const | Assimp::Exporter |
GetIOHandler() const | Assimp::Exporter |
GetOrphanedBlob() const | Assimp::Exporter |
IsDefaultIOHandler() const | Assimp::Exporter |
pimpl | Assimp::Exporter | [protected]
RegisterExporter(const ExportFormatEntry &desc) | Assimp::Exporter |
SetIOHandler(IOSystem *pIOHandler) | Assimp::Exporter |
UnregisterExporter(const char *id) | Assimp::Exporter |
~Exporter() | Assimp::Exporter |


Assimp: Member List

  • Assimp
  • IOStream
Assimp::IOStream Member List
This is the complete list of members for Assimp::IOStream, including all inherited members.
FileSize() const =0 | Assimp::IOStream | [pure virtual]
Flush()=0 | Assimp::IOStream | [pure virtual]
IOStream(void) | Assimp::IOStream | [inline, protected]
Read(void *pvBuffer, size_t pSize, size_t pCount)=0 | Assimp::IOStream | [pure virtual]
Seek(size_t pOffset, aiOrigin pOrigin)=0 | Assimp::IOStream | [pure virtual]
Tell() const =0 | Assimp::IOStream | [pure virtual]
Write(const void *pvBuffer, size_t pSize, size_t pCount)=0 | Assimp::IOStream | [pure virtual]
~IOStream() | Assimp::IOStream | [inline, virtual]


Assimp: Member List

  • Assimp
  • IOSystem
Assimp::IOSystem Member List
This is the complete list of members for Assimp::IOSystem, including all inherited members.
Close(IOStream *pFile)=0 | Assimp::IOSystem | [pure virtual]
ComparePaths(const char *one, const char *second) const | Assimp::IOSystem | [virtual]
ComparePaths(const std::string &one, const std::string &second) const | Assimp::IOSystem | [inline]
Exists(const std::string &pFile) const | Assimp::IOSystem |
Exists(const char *pFile) const =0 | Assimp::IOSystem | [pure virtual]
getOsSeparator() const =0 | Assimp::IOSystem | [pure virtual]
IOSystem() | Assimp::IOSystem |
Open(const char *pFile, const char *pMode="rb")=0 | Assimp::IOSystem | [pure virtual]
Open(const std::string &pFile, const std::string &pMode=std::string("rb")) | Assimp::IOSystem | [inline]
~IOSystem() | Assimp::IOSystem | [virtual]


Assimp: Member List

  • Assimp
  • Importer
Assimp::Importer Member List
This is the complete list of members for Assimp::Importer, including all inherited members.
ApplyPostProcessing(unsigned int pFlags) | Assimp::Importer |
FreeScene() | Assimp::Importer |
GetErrorString() const | Assimp::Importer |
GetExtensionList(aiString &szOut) const | Assimp::Importer |
GetExtensionList(std::string &szOut) const | Assimp::Importer | [inline]
GetImporter(size_t index) const | Assimp::Importer |
GetImporter(const char *szExtension) const | Assimp::Importer |
GetImporterCount() const | Assimp::Importer |
GetImporterIndex(const char *szExtension) const | Assimp::Importer |
GetImporterInfo(size_t index) const | Assimp::Importer |
GetIOHandler() const | Assimp::Importer |
GetMemoryRequirements(aiMemoryInfo &in) const | Assimp::Importer |
GetOrphanedScene() | Assimp::Importer |
GetProgressHandler() const | Assimp::Importer |
GetPropertyBool(const char *szName, bool bErrorReturn=false) const | Assimp::Importer | [inline]
GetPropertyFloat(const char *szName, float fErrorReturn=10e10f) const | Assimp::Importer |
GetPropertyInteger(const char *szName, int iErrorReturn=0xffffffff) const | Assimp::Importer |
GetPropertyString(const char *szName, const std::string &sErrorReturn="") const | Assimp::Importer |
GetScene() const | Assimp::Importer |
Importer() | Assimp::Importer |
Importer(const Importer &other) | Assimp::Importer |
IsDefaultIOHandler() const | Assimp::Importer |
IsDefaultProgressHandler() const | Assimp::Importer |
IsExtensionSupported(const char *szExtension) const | Assimp::Importer |
IsExtensionSupported(const std::string &szExtension) const | Assimp::Importer | [inline]
pimpl | Assimp::Importer | [protected]
Pimpl() | Assimp::Importer | [inline]
Pimpl() const | Assimp::Importer | [inline]
ReadFile(const char *pFile, unsigned int pFlags) | Assimp::Importer |
ReadFile(const std::string &pFile, unsigned int pFlags) | Assimp::Importer |
ReadFileFromMemory(const void *pBuffer, size_t pLength, unsigned int pFlags, const char *pHint="") | Assimp::Importer |
RegisterLoader(BaseImporter *pImp) | Assimp::Importer |
RegisterPPStep(BaseProcess *pImp) | Assimp::Importer |
SetExtraVerbose(bool bDo) | Assimp::Importer |
SetIOHandler(IOSystem *pIOHandler) | Assimp::Importer |
SetProgressHandler(ProgressHandler *pHandler) | Assimp::Importer |
SetPropertyBool(const char *szName, bool value, bool *bWasExisting=NULL) | Assimp::Importer | [inline]
SetPropertyFloat(const char *szName, float fValue, bool *bWasExisting=NULL) | Assimp::Importer |
SetPropertyInteger(const char *szName, int iValue, bool *bWasExisting=NULL) | Assimp::Importer |
SetPropertyString(const char *szName, const std::string &sValue, bool *bWasExisting=NULL) | Assimp::Importer |
UnregisterLoader(BaseImporter *pImp) | Assimp::Importer |
UnregisterPPStep(BaseProcess *pImp) | Assimp::Importer |
ValidateFlags(unsigned int pFlags) const | Assimp::Importer |
~Importer() | Assimp::Importer |


Assimp: Member List

  • Assimp
  • LogStream
Assimp::LogStream Member List
This is the complete list of members for Assimp::LogStream, including all inherited members.
createDefaultStream(aiDefaultLogStream stream, const char *name="AssimpLog.txt", IOSystem *io=NULL) | Assimp::LogStream | [static]
LogStream() | Assimp::LogStream | [inline, protected]
write(const char *message)=0 | Assimp::LogStream | [pure virtual]
~LogStream() | Assimp::LogStream | [inline, virtual]


Assimp: Member List

  • Assimp
  • Logger
Assimp::Logger Member List
This is the complete list of members for Assimp::Logger, including all inherited members.
attachStream(LogStream *pStream, unsigned int severity=Debugging|Err|Warn|Info)=0 | Assimp::Logger | [pure virtual]
debug(const char *message) | Assimp::Logger |
debug(const std::string &message) | Assimp::Logger | [inline]
Debugging enum value | Assimp::Logger |
detatchStream(LogStream *pStream, unsigned int severity=Debugging|Err|Warn|Info)=0 | Assimp::Logger | [pure virtual]
Err enum value | Assimp::Logger |
error(const char *message) | Assimp::Logger |
error(const std::string &message) | Assimp::Logger | [inline]
ErrorSeverity enum name | Assimp::Logger |
getLogSeverity() const | Assimp::Logger | [inline]
info(const char *message) | Assimp::Logger |
info(const std::string &message) | Assimp::Logger | [inline]
Info enum value | Assimp::Logger |
Logger() | Assimp::Logger | [inline, protected]
Logger(LogSeverity severity) | Assimp::Logger | [inline, protected]
LogSeverity enum name | Assimp::Logger |
m_Severity | Assimp::Logger | [protected]
NORMAL enum value | Assimp::Logger |
OnDebug(const char *message)=0 | Assimp::Logger | [protected, pure virtual]
OnError(const char *message)=0 | Assimp::Logger | [protected, pure virtual]
OnInfo(const char *message)=0 | Assimp::Logger | [protected, pure virtual]
OnWarn(const char *essage)=0 | Assimp::Logger | [protected, pure virtual]
setLogSeverity(LogSeverity log_severity) | Assimp::Logger | [inline]
VERBOSE enum value | Assimp::Logger |
warn(const char *message) | Assimp::Logger |
warn(const std::string &message) | Assimp::Logger | [inline]
Warn enum value | Assimp::Logger |
~Logger() | Assimp::Logger | [inline, virtual]


Assimp: Member List

  • Assimp
  • NullLogger
Assimp::NullLogger Member List
This is the complete list of members for Assimp::NullLogger, including all inherited members.
attachStream(LogStream *pStream, unsigned int severity) | Assimp::NullLogger | [inline, virtual]
debug(const char *message) | Assimp::Logger |
debug(const std::string &message) | Assimp::Logger | [inline]
Debugging enum value | Assimp::Logger |
detatchStream(LogStream *pStream, unsigned int severity) | Assimp::NullLogger | [inline, virtual]
Err enum value | Assimp::Logger |
error(const char *message) | Assimp::Logger |
error(const std::string &message) | Assimp::Logger | [inline]
ErrorSeverity enum name | Assimp::Logger |
getLogSeverity() const | Assimp::Logger | [inline]
info(const char *message) | Assimp::Logger |
info(const std::string &message) | Assimp::Logger | [inline]
Info enum value | Assimp::Logger |
Logger() | Assimp::Logger | [inline, protected]
Logger(LogSeverity severity) | Assimp::Logger | [inline, protected]
LogSeverity enum name | Assimp::Logger |
m_Severity | Assimp::Logger | [protected]
NORMAL enum value | Assimp::Logger |
OnDebug(const char *message) | Assimp::NullLogger | [inline, virtual]
OnError(const char *message) | Assimp::NullLogger | [inline, virtual]
OnInfo(const char *message) | Assimp::NullLogger | [inline, virtual]
OnWarn(const char *message) | Assimp::NullLogger | [inline, virtual]
setLogSeverity(LogSeverity log_severity) | Assimp::Logger | [inline]
VERBOSE enum value | Assimp::Logger |
warn(const char *message) | Assimp::Logger |
warn(const std::string &message) | Assimp::Logger | [inline]
Warn enum value | Assimp::Logger |
~Logger() | Assimp::Logger | [inline, virtual]


Assimp: Member List

  • Assimp
  • ProgressHandler
Assimp::ProgressHandler Member List
This is the complete list of members for Assimp::ProgressHandler, including all inherited members.
ProgressHandler() | Assimp::ProgressHandler | [inline, protected]
Update(float percentage=-1.f)=0 | Assimp::ProgressHandler | [pure virtual]
~ProgressHandler() | Assimp::ProgressHandler | [inline, virtual]


Assimp: Member List

aiColor4t< TReal > Member List
This is the complete list of members for aiColor4t< TReal >, including all inherited members.
a | aiColor4t< TReal > |
aiColor4t() | aiColor4t< TReal > | [inline]
aiColor4t(TReal _r, TReal _g, TReal _b, TReal _a) | aiColor4t< TReal > | [inline]
aiColor4t(TReal _r) | aiColor4t< TReal > | [inline]
aiColor4t(const aiColor4t &o) | aiColor4t< TReal > | [inline]
b | aiColor4t< TReal > |
g | aiColor4t< TReal > |
IsBlack() const | aiColor4t< TReal > | [inline]
operator!=(const aiColor4t &other) const | aiColor4t< TReal > |
operator*=(TReal f) | aiColor4t< TReal > |
operator+=(const aiColor4t &o) | aiColor4t< TReal > |
operator-=(const aiColor4t &o) | aiColor4t< TReal > |
operator/=(TReal f) | aiColor4t< TReal > |
operator==(const aiColor4t &other) const | aiColor4t< TReal > |
operator[](unsigned int i) const | aiColor4t< TReal > | [inline]
operator[](unsigned int i) | aiColor4t< TReal > | [inline]
r | aiColor4t< TReal > |


Assimp: Member List

aiMatrix3x3t< TReal > Member List
This is the complete list of members for aiMatrix3x3t< TReal >, including all inherited members.
a1 | aiMatrix3x3t< TReal > |
a2 | aiMatrix3x3t< TReal > |
a3 | aiMatrix3x3t< TReal > |
aiMatrix3x3t() | aiMatrix3x3t< TReal > | [inline]
aiMatrix3x3t(TReal _a1, TReal _a2, TReal _a3, TReal _b1, TReal _b2, TReal _b3, TReal _c1, TReal _c2, TReal _c3) | aiMatrix3x3t< TReal > | [inline]
aiMatrix3x3t(const aiMatrix4x4t< TReal > &pMatrix) | aiMatrix3x3t< TReal > | [inline, explicit]
b1 | aiMatrix3x3t< TReal > |
b2 | aiMatrix3x3t< TReal > |
b3 | aiMatrix3x3t< TReal > |
c1 | aiMatrix3x3t< TReal > |
c2 | aiMatrix3x3t< TReal > |
c3 | aiMatrix3x3t< TReal > |
Determinant() const | aiMatrix3x3t< TReal > | [inline]
FromToMatrix(const aiVector3t< TReal > &from, const aiVector3t< TReal > &to, aiMatrix3x3t &out) | aiMatrix3x3t< TReal > | [inline, static]
Inverse() | aiMatrix3x3t< TReal > | [inline]
operator aiMatrix3x3t< TOther >() const | aiMatrix3x3t< TReal > |
operator!=(const aiMatrix4x4t< TReal > m) const | aiMatrix3x3t< TReal > | [inline]
operator*(const aiMatrix3x3t &m) const | aiMatrix3x3t< TReal > | [inline]
operator*=(const aiMatrix3x3t &m) | aiMatrix3x3t< TReal > | [inline]
operator==(const aiMatrix4x4t< TReal > m) const | aiMatrix3x3t< TReal > | [inline]
operator[](unsigned int p_iIndex) | aiMatrix3x3t< TReal > | [inline]
operator[](unsigned int p_iIndex) const | aiMatrix3x3t< TReal > | [inline]
Rotation(TReal a, const aiVector3t< TReal > &axis, aiMatrix3x3t &out) | aiMatrix3x3t< TReal > | [inline, static]
RotationZ(TReal a, aiMatrix3x3t &out) | aiMatrix3x3t< TReal > | [inline, static]
Translation(const aiVector2t< TReal > &v, aiMatrix3x3t &out) | aiMatrix3x3t< TReal > | [inline, static]
Transpose() | aiMatrix3x3t< TReal > | [inline]


Assimp: Member List

aiMatrix4x4t< TReal > Member List
This is the complete list of members for aiMatrix4x4t< TReal >, including all inherited members.
a1 | aiMatrix4x4t< TReal > |
a2 | aiMatrix4x4t< TReal > |
a3 | aiMatrix4x4t< TReal > |
a4 | aiMatrix4x4t< TReal > |
aiMatrix4x4t() | aiMatrix4x4t< TReal > |
aiMatrix4x4t(TReal _a1, TReal _a2, TReal _a3, TReal _a4, TReal _b1, TReal _b2, TReal _b3, TReal _b4, TReal _c1, TReal _c2, TReal _c3, TReal _c4, TReal _d1, TReal _d2, TReal _d3, TReal _d4) | aiMatrix4x4t< TReal > |
aiMatrix4x4t(const aiMatrix3x3t< TReal > &m) | aiMatrix4x4t< TReal > | [inline, explicit]
b1 | aiMatrix4x4t< TReal > |
b2 | aiMatrix4x4t< TReal > |
b3 | aiMatrix4x4t< TReal > |
b4 | aiMatrix4x4t< TReal > |
c1 | aiMatrix4x4t< TReal > |
c2 | aiMatrix4x4t< TReal > |
c3 | aiMatrix4x4t< TReal > |
c4 | aiMatrix4x4t< TReal > |
d1 | aiMatrix4x4t< TReal > |
d2 | aiMatrix4x4t< TReal > |
d3 | aiMatrix4x4t< TReal > |
d4 | aiMatrix4x4t< TReal > |
Decompose(aiVector3t< TReal > &scaling, aiQuaterniont< TReal > &rotation, aiVector3t< TReal > &position) const | aiMatrix4x4t< TReal > | [inline]
DecomposeNoScaling(aiQuaterniont< TReal > &rotation, aiVector3t< TReal > &position) const | aiMatrix4x4t< TReal > | [inline]
Determinant() const | aiMatrix4x4t< TReal > | [inline]
FromEulerAnglesXYZ(TReal x, TReal y, TReal z) | aiMatrix4x4t< TReal > | [inline]
FromEulerAnglesXYZ(const aiVector3t< TReal > &blubb) | aiMatrix4x4t< TReal > | [inline]
FromToMatrix(const aiVector3t< TReal > &from, const aiVector3t< TReal > &to, aiMatrix4x4t &out) | aiMatrix4x4t< TReal > | [inline, static]
Inverse() | aiMatrix4x4t< TReal > | [inline]
IsIdentity() const | aiMatrix4x4t< TReal > | [inline]
operator aiMatrix4x4t< TOther >() const | aiMatrix4x4t< TReal > |
operator!=(const aiMatrix4x4t m) const | aiMatrix4x4t< TReal > | [inline]
operator*(const aiMatrix4x4t &m) const | aiMatrix4x4t< TReal > | [inline]
operator*=(const aiMatrix4x4t &m) | aiMatrix4x4t< TReal > | [inline]
operator==(const aiMatrix4x4t m) const | aiMatrix4x4t< TReal > | [inline]
operator[](unsigned int p_iIndex) | aiMatrix4x4t< TReal > | [inline]
operator[](unsigned int p_iIndex) const | aiMatrix4x4t< TReal > | [inline]
Rotation(TReal a, const aiVector3t< TReal > &axis, aiMatrix4x4t &out) | aiMatrix4x4t< TReal > | [inline, static]
RotationX(TReal a, aiMatrix4x4t &out) | aiMatrix4x4t< TReal > | [inline, static]
RotationY(TReal a, aiMatrix4x4t &out) | aiMatrix4x4t< TReal > | [inline, static]
RotationZ(TReal a, aiMatrix4x4t &out) | aiMatrix4x4t< TReal > | [inline, static]
Scaling(const aiVector3t< TReal > &v, aiMatrix4x4t &out) | aiMatrix4x4t< TReal > | [inline, static]
Translation(const aiVector3t< TReal > &v, aiMatrix4x4t &out) | aiMatrix4x4t< TReal > | [inline, static]
Transpose() | aiMatrix4x4t< TReal > | [inline]


Assimp: Member List

aiQuaterniont< TReal > Member List
This is the complete list of members for aiQuaterniont< TReal >, including all inherited members.
aiQuaterniont() | aiQuaterniont< TReal > | [inline]
aiQuaterniont(TReal w, TReal x, TReal y, TReal z) | aiQuaterniont< TReal > | [inline]
aiQuaterniont(const aiMatrix3x3t< TReal > &pRotMatrix) | aiQuaterniont< TReal > | [inline]
aiQuaterniont(TReal rotx, TReal roty, TReal rotz) | aiQuaterniont< TReal > | [inline]
aiQuaterniont(aiVector3t< TReal > axis, TReal angle) | aiQuaterniont< TReal > | [inline]
aiQuaterniont(aiVector3t< TReal > normalized) | aiQuaterniont< TReal > | [inline]
Conjugate() | aiQuaterniont< TReal > | [inline]
GetMatrix() const | aiQuaterniont< TReal > | [inline]
Interpolate(aiQuaterniont &pOut, const aiQuaterniont &pStart, const aiQuaterniont &pEnd, TReal pFactor) | aiQuaterniont< TReal > | [inline, static]
Normalize() | aiQuaterniont< TReal > | [inline]
operator!=(const aiQuaterniont &o) const | aiQuaterniont< TReal > |
operator*(const aiQuaterniont &two) const | aiQuaterniont< TReal > | [inline]
operator==(const aiQuaterniont &o) const | aiQuaterniont< TReal > |
Rotate(const aiVector3t< TReal > &in) | aiQuaterniont< TReal > | [inline]
w | aiQuaterniont< TReal > |
x | aiQuaterniont< TReal > |
y | aiQuaterniont< TReal > |
z | aiQuaterniont< TReal > |


Assimp: Member List

aiVector2t< TReal > Member List
This is the complete list of members for aiVector2t< TReal >, including all inherited members.
aiVector2t() | aiVector2t< TReal > | [inline]
aiVector2t(TReal _x, TReal _y) | aiVector2t< TReal > | [inline]
aiVector2t(TReal _xyz) | aiVector2t< TReal > | [inline, explicit]
aiVector2t(const aiVector2t &o) | aiVector2t< TReal > | [inline]
Length() const | aiVector2t< TReal > |
Normalize() | aiVector2t< TReal > |
operator aiVector2t< TOther >() const | aiVector2t< TReal > |
operator!=(const aiVector2t &other) const | aiVector2t< TReal > |
operator*=(TReal f) | aiVector2t< TReal > |
operator+=(const aiVector2t &o) | aiVector2t< TReal > |
operator-=(const aiVector2t &o) | aiVector2t< TReal > |
operator/=(TReal f) | aiVector2t< TReal > |
operator=(TReal f) | aiVector2t< TReal > |
operator==(const aiVector2t &other) const | aiVector2t< TReal > |
operator[](unsigned int i) const | aiVector2t< TReal > |
operator[](unsigned int i) | aiVector2t< TReal > |
Set(TReal pX, TReal pY) | aiVector2t< TReal > |
SquareLength() const | aiVector2t< TReal > |
SymMul(const aiVector2t &o) | aiVector2t< TReal > |
x | aiVector2t< TReal > |
y | aiVector2t< TReal > |


Assimp: Member List

aiVector3t< TReal > Member List
This is the complete list of members for aiVector3t< TReal >, including all inherited members.
aiVector3t() | aiVector3t< TReal > | [inline]
aiVector3t(TReal _x, TReal _y, TReal _z) | aiVector3t< TReal > | [inline]
aiVector3t(TReal _xyz) | aiVector3t< TReal > | [inline, explicit]
aiVector3t(const aiVector3t &o) | aiVector3t< TReal > | [inline]
Length() const | aiVector3t< TReal > |
Normalize() | aiVector3t< TReal > |
operator aiVector3t< TOther >() const | aiVector3t< TReal > |
operator!=(const aiVector3t &other) const | aiVector3t< TReal > |
operator*=(TReal f) | aiVector3t< TReal > |
operator*=(const aiMatrix3x3t< TReal > &mat) | aiVector3t< TReal > |
operator*=(const aiMatrix4x4t< TReal > &mat) | aiVector3t< TReal > |
operator+=(const aiVector3t &o) | aiVector3t< TReal > |
operator-=(const aiVector3t &o) | aiVector3t< TReal > |
operator/=(TReal f) | aiVector3t< TReal > |
operator==(const aiVector3t &other) const | aiVector3t< TReal > |
operator[](unsigned int i) const | aiVector3t< TReal > |
operator[](unsigned int i) | aiVector3t< TReal > |
Set(TReal pX, TReal pY, TReal pZ) | aiVector3t< TReal > |
SquareLength() const | aiVector3t< TReal > |
SymMul(const aiVector3t &o) | aiVector3t< TReal > |
x | aiVector3t< TReal > |
y | aiVector3t< TReal > |
z | aiVector3t< TReal > |


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- k -

  • kill() : Assimp::DefaultLogger


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- l -

  • length : aiString
  • Length() : aiVector2t< TReal > , aiVector3t< TReal >
  • Logger() : Assimp::Logger
  • LogSeverity : Assimp::Logger
  • LogStream() : Assimp::LogStream


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- m -

  • m_Severity : Assimp::Logger
  • mAngleInnerCone : aiLight
  • mAngleOuterCone : aiLight
  • mAnimations : aiScene
  • mAnimMeshes : aiMesh
  • mAspect : aiCamera
  • mAttenuationConstant : aiLight
  • mAttenuationLinear : aiLight
  • mAttenuationQuadratic : aiLight
  • mAuthor : aiImporterDesc
  • mBitangents : aiAnimMesh , aiMesh
  • mBones : aiMesh
  • mCameras : aiScene
  • mChannels : aiAnimation
  • mChildren : aiNode
  • mClipPlaneFar : aiCamera
  • mClipPlaneNear : aiCamera
  • mColorAmbient : aiLight
  • mColorDiffuse : aiLight
  • mColors : aiAnimMesh , aiMesh
  • mColorSpecular : aiLight
  • mComments : aiImporterDesc
  • mDescription : Assimp::Exporter::ExportFormatEntry
  • mDirection : aiLight
  • mDuration : aiAnimation
  • mEnforcePP : Assimp::Exporter::ExportFormatEntry
  • mErrorText : Assimp::BaseImporter
  • mExportFunction : Assimp::Exporter::ExportFormatEntry
  • mFaces : aiMesh
  • mFileExtensions : aiImporterDesc
  • mFlags : aiImporterDesc , aiScene
  • mHeight : aiTexture
  • mHorizontalFOV : aiCamera
  • mIndices : aiFace
  • mKeys : aiMeshAnim
  • mLights : aiScene
  • mLookAt : aiCamera
  • mMaintainer : aiImporterDesc
  • mMaterialIndex : aiMesh
  • mMaterials : aiScene
  • mMaxMajor : aiImporterDesc
  • mMaxMinor : aiImporterDesc
  • mMeshChannels : aiAnimation
  • mMeshes : aiNode , aiScene
  • mMinMajor : aiImporterDesc
  • mMinMinor : aiImporterDesc
  • mName : aiMeshAnim , aiAnimation , aiCamera , aiImporterDesc , aiLight , aiBone , aiMesh , aiNode
  • mNodeName : aiNodeAnim
  • mNormals : aiAnimMesh , aiMesh
  • mNumAllocated : aiMaterial
  • mNumAnimations : aiScene
  • mNumAnimMeshes : aiMesh
  • mNumBones : aiMesh
  • mNumCameras : aiScene
  • mNumChannels : aiAnimation
  • mNumChildren : aiNode
  • mNumFaces : aiMesh
  • mNumIndices : aiFace
  • mNumKeys : aiMeshAnim
  • mNumLights : aiScene
  • mNumMaterials : aiScene
  • mNumMeshChannels : aiAnimation
  • mNumMeshes : aiScene , aiNode
  • mNumPositionKeys : aiNodeAnim
  • mNumProperties : aiMaterial
  • mNumRotationKeys : aiNodeAnim
  • mNumScalingKeys : aiNodeAnim
  • mNumTextures : aiScene
  • mNumUVComponents : aiMesh
  • mNumVertices : aiAnimMesh , aiMesh
  • mNumWeights : aiBone
  • mOffsetMatrix : aiBone
  • mParent : aiNode
  • mPosition : aiLight , aiCamera
  • mPositionKeys : aiNodeAnim
  • mPostState : aiNodeAnim
  • mPreState : aiNodeAnim
  • mPrimitiveTypes : aiMesh
  • mPrivate : aiScene
  • mProperties : aiMaterial
  • mRootNode : aiScene
  • mRotation : aiUVTransform
  • mRotationKeys : aiNodeAnim
  • mScaling : aiUVTransform
  • mScalingKeys : aiNodeAnim
  • mTangents : aiMesh , aiAnimMesh
  • mTextureCoords : aiMesh , aiAnimMesh
  • mTextures : aiScene
  • mTicksPerSecond : aiAnimation
  • mTime : aiQuatKey , aiVectorKey , aiMeshKey
  • mTransformation : aiNode
  • mTranslation : aiUVTransform
  • mType : aiLight
  • mUp : aiCamera
  • mValue : aiMeshKey , aiQuatKey , aiVectorKey
  • mVertexId : aiVertexWeight
  • mVertices : aiAnimMesh , aiMesh
  • mWeight : aiVertexWeight
  • mWeights : aiBone
  • mWidth : aiTexture


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- n -

  • name : aiExportDataBlob
  • next : aiExportDataBlob
  • NORMAL : Assimp::Logger
  • Normalize() : aiQuaterniont< TReal > , aiVector2t< TReal > , aiVector3t< TReal >


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- o -

  • OnDebug()
: Assimp::Logger
, Assimp::NullLogger
  • OnError()
: Assimp::NullLogger
, Assimp::Logger
  • OnInfo()
: Assimp::Logger
, Assimp::NullLogger
  • OnWarn()
: Assimp::NullLogger
, Assimp::Logger
  • Open() : Assimp::IOSystem
  • OpenProc : aiFileIO
  • operator aiColor4D() : aiTexel
  • operator aiMatrix3x3t< TOther >() : aiMatrix3x3t< TReal >
  • operator aiMatrix4x4t< TOther >() : aiMatrix4x4t< TReal >
  • operator aiVector2t< TOther >() : aiVector2t< TReal >
  • operator aiVector3t< TOther >() : aiVector3t< TReal >
  • operator T *() : Assimp::ScopeGuard< T >
  • operator!=() : aiVectorKey , aiQuatKey , aiMeshKey , aiColor4t< TReal > , aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal > , aiFace , aiQuaterniont< TReal > , aiTexel , aiColor3D , aiString , aiVector2t< TReal > , aiVector3t< TReal >
  • operator()() : Assimp::Interpolator< T >
  • operator*() : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal > , aiQuaterniont< TReal > , aiColor3D
  • operator*=() : aiColor4t< TReal > , aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal > , aiVector2t< TReal > , aiVector3t< TReal >
  • operator+() : aiColor3D
  • operator+=() : aiColor4t< TReal > , aiVector2t< TReal > , aiVector3t< TReal >
  • operator-() : aiColor3D
  • operator-=() : aiColor4t< TReal > , aiVector2t< TReal > , aiVector3t< TReal >
  • operator->() : Assimp::ScopeGuard< T >
  • operator/=() : aiVector3t< TReal > , aiColor4t< TReal > , aiVector2t< TReal >
  • operator<() : aiVectorKey , aiQuatKey , aiMeshKey
  • operator=() : aiFace , aiString , aiVector2t< TReal >
  • operator==() : aiVector2t< TReal > , aiQuatKey , aiColor4t< TReal > , aiMatrix4x4t< TReal > , aiColor3D , aiVector3t< TReal > , aiVectorKey , aiQuaterniont< TReal > , aiString , aiMatrix3x3t< TReal > , aiTexel , aiMeshKey , aiFace
  • operator>() : aiVectorKey , aiQuatKey , aiMeshKey
  • operator[]() : aiVector3t< TReal > , aiColor3D , aiVector2t< TReal > , aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal > , aiColor4t< TReal > , aiColor3D , aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal > , aiVector2t< TReal > , aiVector3t< TReal >


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- z -

  • z : aiQuaterniont< TReal > , aiVector3t< TReal >


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- ~ -

  • ~aiAnimation() : aiAnimation
  • ~aiAnimMesh() : aiAnimMesh
  • ~aiBone() : aiBone
  • ~aiExportDataBlob() : aiExportDataBlob
  • ~aiFace() : aiFace
  • ~aiMaterial() : aiMaterial
  • ~aiMesh() : aiMesh
  • ~aiMeshAnim() : aiMeshAnim
  • ~aiNode() : aiNode
  • ~aiNodeAnim() : aiNodeAnim
  • ~aiScene() : aiScene
  • ~aiTexture() : aiTexture
  • ~BaseImporter() : Assimp::BaseImporter
  • ~Exporter() : Assimp::Exporter
  • ~Importer() : Assimp::Importer
  • ~IOStream() : Assimp::IOStream
  • ~IOSystem() : Assimp::IOSystem
  • ~Logger() : Assimp::Logger
  • ~LogStream() : Assimp::LogStream
  • ~ProgressHandler() : Assimp::ProgressHandler
  • ~ScopeGuard() : Assimp::ScopeGuard< T >


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- b -

  • b : aiColor4t< TReal > , aiTexel , aiColor3D , aiPlane
  • b1 : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • b2 : aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal >
  • b3 : aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal >
  • b4 : aiMatrix4x4t< TReal >
  • BaseImporter() : Assimp::BaseImporter


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- c -

  • c : aiPlane
  • c1 : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • c2 : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • c3 : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • c4 : aiMatrix4x4t< TReal >
  • C_Str() : aiString
  • callback : aiLogStream
  • CanRead() : Assimp::BaseImporter
  • CheckFormat() : aiTexture
  • CheckMagicToken() : Assimp::BaseImporter
  • Clear() : aiString , aiMaterial
  • Close() : Assimp::IOSystem
  • CloseProc : aiFileIO
  • ComparePaths() : Assimp::IOSystem
  • Conjugate() : aiQuaterniont< TReal >
  • ConvertToUTF8() : Assimp::BaseImporter
  • CopyPropertyList() : aiMaterial
  • create() : Assimp::DefaultLogger
  • createDefaultStream() : Assimp::LogStream


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- d -

  • d : aiPlane
  • d1 : aiMatrix4x4t< TReal >
  • d2 : aiMatrix4x4t< TReal >
  • d3 : aiMatrix4x4t< TReal >
  • d4 : aiMatrix4x4t< TReal >
  • data : aiExportDataBlob , aiString
  • debug() : Assimp::Logger
  • Debugging : Assimp::Logger
  • Decompose() : aiMatrix4x4t< TReal >
  • DecomposeNoScaling() : aiMatrix4x4t< TReal >
  • description : aiExportFormatDesc
  • detatchStream()
: Assimp::NullLogger
, Assimp::Logger
, Assimp::DefaultLogger
  • Determinant() : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • dir : aiRay
  • dismiss() : Assimp::ScopeGuard< T >


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- e -

  • elem_type : aiVectorKey , aiQuatKey , aiMeshKey
  • Err : Assimp::Logger
  • error() : Assimp::Logger
  • ErrorSeverity : Assimp::Logger
  • Exists() : Assimp::IOSystem
  • Export() : Assimp::Exporter
  • Exporter() : Assimp::Exporter
  • ExportFormatEntry() : Assimp::Exporter::ExportFormatEntry
  • ExportToBlob() : Assimp::Exporter


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- f -

  • fileExtension : aiExportFormatDesc
  • FileSize() : Assimp::IOStream
  • FileSizeProc : aiFile
  • FindNode() : aiNode
  • Flush() : Assimp::IOStream
  • FlushProc : aiFile
  • fpExportFunc : Assimp::Exporter
  • FreeBlob() : Assimp::Exporter
  • FreeScene() : Assimp::Importer
  • FromEulerAnglesXYZ() : aiMatrix4x4t< TReal >
  • FromToMatrix() : aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal >


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- g -

  • g : aiColor4t< TReal > , aiTexel , aiColor3D
  • Get() : aiMaterial
  • get() : Assimp::DefaultLogger
  • GetBlob() : Assimp::Exporter
  • GetCameraMatrix() : aiCamera
  • GetErrorString()
: Assimp::Exporter
, Assimp::Importer
  • GetErrorText() : Assimp::BaseImporter
  • GetExportFormatCount() : Assimp::Exporter
  • GetExportFormatDescription() : Assimp::Exporter
  • GetExtension() : Assimp::BaseImporter
  • GetExtensionList()
: Assimp::Importer
, Assimp::BaseImporter
, Assimp::Importer
  • GetImporter() : Assimp::Importer
  • GetImporterCount() : Assimp::Importer
  • GetImporterIndex() : Assimp::Importer
  • GetImporterInfo() : Assimp::Importer
  • GetInfo() : Assimp::BaseImporter
  • GetIOHandler()
: Assimp::Exporter
, Assimp::Importer
  • getLogSeverity() : Assimp::Logger
  • GetMatrix() : aiQuaterniont< TReal >
  • GetMemoryRequirements() : Assimp::Importer
  • GetNumColorChannels() : aiMesh
  • GetNumUVChannels() : aiMesh
  • GetOrphanedBlob() : Assimp::Exporter
  • GetOrphanedScene() : Assimp::Importer
  • getOsSeparator() : Assimp::IOSystem
  • GetProgressHandler() : Assimp::Importer
  • GetPropertyBool() : Assimp::Importer
  • GetPropertyFloat() : Assimp::Importer
  • GetPropertyInteger() : Assimp::Importer
  • GetPropertyString() : Assimp::Importer
  • GetScene() : Assimp::Importer
  • GetTexture() : aiMaterial
  • GetTextureCount() : aiMaterial


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- h -

  • HasAnimations() : aiScene
  • HasBones() : aiMesh
  • HasCameras() : aiScene
  • HasFaces() : aiMesh
  • HasLights() : aiScene
  • HasMaterials() : aiScene
  • HasMeshes() : aiScene
  • HasNormals() : aiAnimMesh , aiMesh
  • HasPositions() : aiMesh , aiAnimMesh
  • HasTangentsAndBitangents() : aiMesh , aiAnimMesh
  • HasTextureCoords() : aiMesh , aiAnimMesh
  • HasTextures() : aiScene
  • HasVertexColors() : aiMesh , aiAnimMesh


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- i -

  • id : aiExportFormatDesc
  • Importer : Assimp::BaseImporter , Assimp::Importer
  • info() : Assimp::Logger
  • Info : Assimp::Logger
  • InternReadFile() : Assimp::BaseImporter
  • Interpolate() : aiQuaterniont< TReal >
  • Inverse() : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • IOStream() : Assimp::IOStream
  • IOSystem() : Assimp::IOSystem
  • IsBlack() : aiColor3D , aiColor4t< TReal >
  • IsDefaultIOHandler()
: Assimp::Exporter
, Assimp::Importer
  • IsDefaultProgressHandler() : Assimp::Importer
  • IsExtensionSupported() : Assimp::Importer
  • IsIdentity() : aiMatrix4x4t< TReal >
  • isNullLogger() : Assimp::DefaultLogger


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- p -

  • pcData : aiTexture
  • pimpl : Assimp::Exporter
  • Pimpl() : Assimp::Importer
  • pimpl : Assimp::Importer
  • pos : aiRay
  • progress : Assimp::BaseImporter
  • ProgressHandler() : Assimp::ProgressHandler


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- r -

  • r : aiColor4t< TReal > , aiTexel , aiColor3D
  • Read() : Assimp::IOStream
  • ReadFile()
: Assimp::Importer
, Assimp::BaseImporter
  • ReadFileFromMemory() : Assimp::Importer
  • ReadProc : aiFile
  • RegisterExporter() : Assimp::Exporter
  • RegisterLoader() : Assimp::Importer
  • RegisterPPStep() : Assimp::Importer
  • RemoveProperty() : aiMaterial
  • Rotate() : aiQuaterniont< TReal >
  • Rotation() : aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal >
  • RotationX() : aiMatrix4x4t< TReal >
  • RotationY() : aiMatrix4x4t< TReal >
  • RotationZ() : aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal >


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- s -

  • Scaling() : aiMatrix4x4t< TReal >
  • ScopeGuard() : Assimp::ScopeGuard< T >
  • SearchFileHeaderForToken() : Assimp::BaseImporter
  • Seek() : Assimp::IOStream
  • SeekProc : aiFile
  • sentinel : aiPropertyStore
  • Set() : aiString , aiVector2t< TReal > , aiVector3t< TReal >
  • set() : Assimp::DefaultLogger
  • SetExtraVerbose() : Assimp::Importer
  • SetIOHandler()
: Assimp::Exporter
, Assimp::Importer
  • setLogSeverity() : Assimp::Logger
  • SetProgressHandler() : Assimp::Importer
  • SetPropertyBool() : Assimp::Importer
  • SetPropertyFloat() : Assimp::Importer
  • SetPropertyInteger() : Assimp::Importer
  • SetPropertyString() : Assimp::Importer
  • SetupProperties() : Assimp::BaseImporter
  • SimpleExtensionCheck() : Assimp::BaseImporter
  • size : aiExportDataBlob
  • SquareLength() : aiVector3t< TReal > , aiVector2t< TReal >
  • SymMul() : aiVector2t< TReal > , aiVector3t< TReal >


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- t -

  • Tell() : Assimp::IOStream
  • TellProc : aiFile
  • TextFileToBuffer() : Assimp::BaseImporter
  • Translation() : aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal >
  • Transpose() : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- u -

  • UnregisterExporter() : Assimp::Exporter
  • UnregisterLoader() : Assimp::Importer
  • UnregisterPPStep() : Assimp::Importer
  • Update() : Assimp::ProgressHandler
  • user : aiLogStream
  • UserData : aiFileIO , aiFile


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- v -

  • ValidateFlags() : Assimp::Importer
  • VERBOSE : Assimp::Logger


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- w -

  • w : aiQuaterniont< TReal >
  • warn() : Assimp::Logger
  • Warn : Assimp::Logger
  • warn() : Assimp::Logger
  • write() : Assimp::LogStream
  • Write() : Assimp::IOStream
  • WriteProc : aiFile


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- x -

  • x : aiQuaterniont< TReal > , aiVector3t< TReal > , aiVector2t< TReal >


Assimp: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • x
  • y
  • z
  • ~
Here is a list of all class members with links to the classes they belong to:

- y -

  • y : aiQuaterniont< TReal > , aiVector3t< TReal > , aiVector2t< TReal >


Assimp: Class Members - Enumerations

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • ErrorSeverity : Assimp::Logger
  • LogSeverity : Assimp::Logger


Assimp: Class Members - Enumerator

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • Debugging : Assimp::Logger
  • Err : Assimp::Logger
  • Info : Assimp::Logger
  • NORMAL : Assimp::Logger
  • VERBOSE : Assimp::Logger
  • Warn : Assimp::Logger


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- a -

  • AddBinaryProperty() : aiMaterial
  • AddProperty() : aiMaterial
  • aiAnimation() : aiAnimation
  • aiAnimMesh() : aiAnimMesh
  • aiBone() : aiBone
  • aiCamera() : aiCamera
  • aiColor3D() : aiColor3D
  • aiColor4t() : aiColor4t< TReal >
  • aiExportDataBlob() : aiExportDataBlob
  • aiFace() : aiFace
  • aiLight() : aiLight
  • aiMaterial() : aiMaterial
  • aiMatrix3x3t() : aiMatrix3x3t< TReal >
  • aiMatrix4x4t() : aiMatrix4x4t< TReal >
  • aiMesh() : aiMesh
  • aiMeshAnim() : aiMeshAnim
  • aiMeshKey() : aiMeshKey
  • aiNode() : aiNode
  • aiNodeAnim() : aiNodeAnim
  • aiPlane() : aiPlane
  • aiQuaterniont() : aiQuaterniont< TReal >
  • aiQuatKey() : aiQuatKey
  • aiRay() : aiRay
  • aiScene() : aiScene
  • aiString() : aiString
  • aiTexture() : aiTexture
  • aiUVTransform() : aiUVTransform
  • aiVector2t() : aiVector2t< TReal >
  • aiVector3t() : aiVector3t< TReal >
  • aiVectorKey() : aiVectorKey
  • aiVertexWeight() : aiVertexWeight
  • Append() : aiString
  • ApplyPostProcessing() : Assimp::Importer
  • attachStream()
: Assimp::Logger
, Assimp::NullLogger
, Assimp::DefaultLogger


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- k -

  • kill() : Assimp::DefaultLogger


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- l -

  • Length() : aiVector2t< TReal > , aiVector3t< TReal >
  • Logger() : Assimp::Logger
  • LogStream() : Assimp::LogStream


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- n -

  • Normalize() : aiQuaterniont< TReal > , aiVector3t< TReal > , aiVector2t< TReal >


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- o -

  • OnDebug()
: Assimp::Logger
, Assimp::NullLogger
  • OnError()
: Assimp::NullLogger
, Assimp::Logger
  • OnInfo()
: Assimp::Logger
, Assimp::NullLogger
  • OnWarn()
: Assimp::NullLogger
, Assimp::Logger
  • Open() : Assimp::IOSystem
  • operator aiColor4D() : aiTexel
  • operator aiMatrix3x3t< TOther >() : aiMatrix3x3t< TReal >
  • operator aiMatrix4x4t< TOther >() : aiMatrix4x4t< TReal >
  • operator aiVector2t< TOther >() : aiVector2t< TReal >
  • operator aiVector3t< TOther >() : aiVector3t< TReal >
  • operator T *() : Assimp::ScopeGuard< T >
  • operator!=() : aiVectorKey , aiQuatKey , aiMeshKey , aiColor4t< TReal > , aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal > , aiFace , aiQuaterniont< TReal > , aiTexel , aiColor3D , aiString , aiVector2t< TReal > , aiVector3t< TReal >
  • operator()() : Assimp::Interpolator< T >
  • operator*() : aiMatrix4x4t< TReal > , aiQuaterniont< TReal > , aiColor3D , aiMatrix3x3t< TReal >
  • operator*=() : aiColor4t< TReal > , aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal > , aiVector2t< TReal > , aiVector3t< TReal >
  • operator+() : aiColor3D
  • operator+=() : aiColor4t< TReal > , aiVector2t< TReal > , aiVector3t< TReal >
  • operator-() : aiColor3D
  • operator-=() : aiColor4t< TReal > , aiVector2t< TReal > , aiVector3t< TReal >
  • operator->() : Assimp::ScopeGuard< T >
  • operator/=() : aiColor4t< TReal > , aiVector2t< TReal > , aiVector3t< TReal >
  • operator<() : aiVectorKey , aiQuatKey , aiMeshKey
  • operator=() : aiString , aiFace , aiString , aiVector2t< TReal >
  • operator==() : aiVector2t< TReal > , aiMeshKey , aiMatrix3x3t< TReal > , aiFace , aiString , aiVector3t< TReal > , aiColor3D , aiMatrix4x4t< TReal > , aiQuaterniont< TReal > , aiTexel , aiColor4t< TReal > , aiVectorKey , aiQuatKey
  • operator>() : aiMeshKey , aiQuatKey , aiVectorKey
  • operator[]() : aiVector3t< TReal > , aiColor4t< TReal > , aiColor3D , aiVector2t< TReal > , aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal > , aiVector3t< TReal > , aiMatrix3x3t< TReal > , aiColor3D , aiColor4t< TReal > , aiMatrix4x4t< TReal > , aiVector2t< TReal >


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- ~ -

  • ~aiAnimation() : aiAnimation
  • ~aiAnimMesh() : aiAnimMesh
  • ~aiBone() : aiBone
  • ~aiExportDataBlob() : aiExportDataBlob
  • ~aiFace() : aiFace
  • ~aiMaterial() : aiMaterial
  • ~aiMesh() : aiMesh
  • ~aiMeshAnim() : aiMeshAnim
  • ~aiNode() : aiNode
  • ~aiNodeAnim() : aiNodeAnim
  • ~aiScene() : aiScene
  • ~aiTexture() : aiTexture
  • ~BaseImporter() : Assimp::BaseImporter
  • ~Exporter() : Assimp::Exporter
  • ~Importer() : Assimp::Importer
  • ~IOStream() : Assimp::IOStream
  • ~IOSystem() : Assimp::IOSystem
  • ~Logger() : Assimp::Logger
  • ~LogStream() : Assimp::LogStream
  • ~ProgressHandler() : Assimp::ProgressHandler
  • ~ScopeGuard() : Assimp::ScopeGuard< T >


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- b -

  • BaseImporter() : Assimp::BaseImporter


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- c -

  • C_Str() : aiString
  • CanRead() : Assimp::BaseImporter
  • CheckFormat() : aiTexture
  • CheckMagicToken() : Assimp::BaseImporter
  • Clear() : aiMaterial , aiString
  • Close() : Assimp::IOSystem
  • ComparePaths() : Assimp::IOSystem
  • Conjugate() : aiQuaterniont< TReal >
  • ConvertToUTF8() : Assimp::BaseImporter
  • CopyPropertyList() : aiMaterial
  • create() : Assimp::DefaultLogger
  • createDefaultStream() : Assimp::LogStream


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- d -

  • debug() : Assimp::Logger
  • Decompose() : aiMatrix4x4t< TReal >
  • DecomposeNoScaling() : aiMatrix4x4t< TReal >
  • detatchStream()
: Assimp::NullLogger
, Assimp::DefaultLogger
, Assimp::Logger
  • Determinant() : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • dismiss() : Assimp::ScopeGuard< T >


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- e -

  • error() : Assimp::Logger
  • Exists() : Assimp::IOSystem
  • Export() : Assimp::Exporter
  • Exporter() : Assimp::Exporter
  • ExportFormatEntry() : Assimp::Exporter::ExportFormatEntry
  • ExportToBlob() : Assimp::Exporter


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- f -

  • FileSize() : Assimp::IOStream
  • FindNode() : aiNode
  • Flush() : Assimp::IOStream
  • FreeBlob() : Assimp::Exporter
  • FreeScene() : Assimp::Importer
  • FromEulerAnglesXYZ() : aiMatrix4x4t< TReal >
  • FromToMatrix() : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- g -

  • Get() : aiMaterial
  • get() : Assimp::DefaultLogger
  • GetBlob() : Assimp::Exporter
  • GetCameraMatrix() : aiCamera
  • GetErrorString()
: Assimp::Exporter
, Assimp::Importer
  • GetErrorText() : Assimp::BaseImporter
  • GetExportFormatCount() : Assimp::Exporter
  • GetExportFormatDescription() : Assimp::Exporter
  • GetExtension() : Assimp::BaseImporter
  • GetExtensionList()
: Assimp::Importer
, Assimp::BaseImporter
  • GetImporter() : Assimp::Importer
  • GetImporterCount() : Assimp::Importer
  • GetImporterIndex() : Assimp::Importer
  • GetImporterInfo() : Assimp::Importer
  • GetInfo() : Assimp::BaseImporter
  • GetIOHandler()
: Assimp::Exporter
, Assimp::Importer
  • getLogSeverity() : Assimp::Logger
  • GetMatrix() : aiQuaterniont< TReal >
  • GetMemoryRequirements() : Assimp::Importer
  • GetNumColorChannels() : aiMesh
  • GetNumUVChannels() : aiMesh
  • GetOrphanedBlob() : Assimp::Exporter
  • GetOrphanedScene() : Assimp::Importer
  • getOsSeparator() : Assimp::IOSystem
  • GetProgressHandler() : Assimp::Importer
  • GetPropertyBool() : Assimp::Importer
  • GetPropertyFloat() : Assimp::Importer
  • GetPropertyInteger() : Assimp::Importer
  • GetPropertyString() : Assimp::Importer
  • GetScene() : Assimp::Importer
  • GetTexture() : aiMaterial
  • GetTextureCount() : aiMaterial


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- h -

  • HasAnimations() : aiScene
  • HasBones() : aiMesh
  • HasCameras() : aiScene
  • HasFaces() : aiMesh
  • HasLights() : aiScene
  • HasMaterials() : aiScene
  • HasMeshes() : aiScene
  • HasNormals() : aiAnimMesh , aiMesh
  • HasPositions() : aiMesh , aiAnimMesh
  • HasTangentsAndBitangents() : aiMesh , aiAnimMesh
  • HasTextureCoords() : aiMesh , aiAnimMesh
  • HasTextures() : aiScene
  • HasVertexColors() : aiMesh , aiAnimMesh


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- i -

  • Importer() : Assimp::Importer
  • info() : Assimp::Logger
  • InternReadFile() : Assimp::BaseImporter
  • Interpolate() : aiQuaterniont< TReal >
  • Inverse() : aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal >
  • IOStream() : Assimp::IOStream
  • IOSystem() : Assimp::IOSystem
  • IsBlack() : aiColor4t< TReal > , aiColor3D
  • IsDefaultIOHandler()
: Assimp::Exporter
, Assimp::Importer
  • IsDefaultProgressHandler() : Assimp::Importer
  • IsExtensionSupported() : Assimp::Importer
  • IsIdentity() : aiMatrix4x4t< TReal >
  • isNullLogger() : Assimp::DefaultLogger


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- p -

  • Pimpl() : Assimp::Importer
  • ProgressHandler() : Assimp::ProgressHandler


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- r -

  • Read() : Assimp::IOStream
  • ReadFile()
: Assimp::Importer
, Assimp::BaseImporter
, Assimp::Importer
  • ReadFileFromMemory() : Assimp::Importer
  • RegisterExporter() : Assimp::Exporter
  • RegisterLoader() : Assimp::Importer
  • RegisterPPStep() : Assimp::Importer
  • RemoveProperty() : aiMaterial
  • Rotate() : aiQuaterniont< TReal >
  • Rotation() : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • RotationX() : aiMatrix4x4t< TReal >
  • RotationY() : aiMatrix4x4t< TReal >
  • RotationZ() : aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal >


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- s -

  • Scaling() : aiMatrix4x4t< TReal >
  • ScopeGuard() : Assimp::ScopeGuard< T >
  • SearchFileHeaderForToken() : Assimp::BaseImporter
  • Seek() : Assimp::IOStream
  • Set() : aiVector2t< TReal > , aiVector3t< TReal >
  • set() : Assimp::DefaultLogger
  • Set() : aiString
  • SetExtraVerbose() : Assimp::Importer
  • SetIOHandler()
: Assimp::Exporter
, Assimp::Importer
  • setLogSeverity() : Assimp::Logger
  • SetProgressHandler() : Assimp::Importer
  • SetPropertyBool() : Assimp::Importer
  • SetPropertyFloat() : Assimp::Importer
  • SetPropertyInteger() : Assimp::Importer
  • SetPropertyString() : Assimp::Importer
  • SetupProperties() : Assimp::BaseImporter
  • SimpleExtensionCheck() : Assimp::BaseImporter
  • SquareLength() : aiVector2t< TReal > , aiVector3t< TReal >
  • SymMul() : aiVector2t< TReal > , aiVector3t< TReal >


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- t -

  • Tell() : Assimp::IOStream
  • TextFileToBuffer() : Assimp::BaseImporter
  • Translation() : aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal >
  • Transpose() : aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal >


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- u -

  • UnregisterExporter() : Assimp::Exporter
  • UnregisterLoader() : Assimp::Importer
  • UnregisterPPStep() : Assimp::Importer
  • Update() : Assimp::ProgressHandler


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- v -

  • ValidateFlags() : Assimp::Importer


Assimp: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • v
  • w
  • ~

- w -

  • warn() : Assimp::Logger
  • Write() : Assimp::IOStream
  • write() : Assimp::LogStream


Assimp: Class Members - Related Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • Importer : Assimp::BaseImporter


Assimp: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • elem_type : aiVectorKey , aiMeshKey , aiQuatKey
  • fpExportFunc : Assimp::Exporter


Assimp: Class Members - Variables

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Related Functions
  • a
  • b
  • c
  • d
  • f
  • g
  • i
  • l
  • m
  • n
  • o
  • p
  • r
  • s
  • t
  • u
  • w
  • x
  • y
  • z

- a -

  • a : aiColor4t< TReal > , aiTexel , aiPlane
  • a1 : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • a2 : aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal >
  • a3 : aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal >
  • a4 : aiMatrix4x4t< TReal >
  • achFormatHint : aiTexture

- b -

  • b : aiColor4t< TReal > , aiTexel , aiColor3D , aiPlane
  • b1 : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • b2 : aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal >
  • b3 : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • b4 : aiMatrix4x4t< TReal >

- c -

  • c : aiPlane
  • c1 : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • c2 : aiMatrix3x3t< TReal > , aiMatrix4x4t< TReal >
  • c3 : aiMatrix4x4t< TReal > , aiMatrix3x3t< TReal >
  • c4 : aiMatrix4x4t< TReal >
  • callback : aiLogStream
  • CloseProc : aiFileIO

- d -

  • d : aiPlane
  • d1 : aiMatrix4x4t< TReal >
  • d2 : aiMatrix4x4t< TReal >
  • d3 : aiMatrix4x4t< TReal >
  • d4 : aiMatrix4x4t< TReal >
  • data : aiString , aiExportDataBlob
  • description : aiExportFormatDesc
  • dir : aiRay

- f -

  • fileExtension : aiExportFormatDesc
  • FileSizeProc : aiFile
  • FlushProc : aiFile

- g -

  • g : aiColor4t< TReal > , aiColor3D , aiTexel

- i -

  • id : aiExportFormatDesc

- l -

  • length : aiString

- m -

  • m_Severity : Assimp::Logger
  • mAngleInnerCone : aiLight
  • mAngleOuterCone : aiLight
  • mAnimations : aiScene
  • mAnimMeshes : aiMesh
  • mAspect : aiCamera
  • mAttenuationConstant : aiLight
  • mAttenuationLinear : aiLight
  • mAttenuationQuadratic : aiLight
  • mAuthor : aiImporterDesc
  • mBitangents : aiAnimMesh , aiMesh
  • mBones : aiMesh
  • mCameras : aiScene
  • mChannels : aiAnimation
  • mChildren : aiNode
  • mClipPlaneFar : aiCamera
  • mClipPlaneNear : aiCamera
  • mColorAmbient : aiLight
  • mColorDiffuse : aiLight
  • mColors : aiAnimMesh , aiMesh
  • mColorSpecular : aiLight
  • mComments : aiImporterDesc
  • mDescription : Assimp::Exporter::ExportFormatEntry
  • mDirection : aiLight
  • mDuration : aiAnimation
  • mEnforcePP : Assimp::Exporter::ExportFormatEntry
  • mErrorText : Assimp::BaseImporter
  • mExportFunction : Assimp::Exporter::ExportFormatEntry
  • mFaces : aiMesh
  • mFileExtensions : aiImporterDesc
  • mFlags : aiImporterDesc , aiScene
  • mHeight : aiTexture
  • mHorizontalFOV : aiCamera
  • mIndices : aiFace
  • mKeys : aiMeshAnim
  • mLights : aiScene
  • mLookAt : aiCamera
  • mMaintainer : aiImporterDesc
  • mMaterialIndex : aiMesh
  • mMaterials : aiScene
  • mMaxMajor : aiImporterDesc
  • mMaxMinor : aiImporterDesc
  • mMeshChannels : aiAnimation
  • mMeshes : aiNode , aiScene
  • mMinMajor : aiImporterDesc
  • mMinMinor : aiImporterDesc
  • mName : aiMeshAnim , aiAnimation , aiCamera , aiImporterDesc , aiLight , aiBone , aiMesh , aiNode
  • mNodeName : aiNodeAnim
  • mNormals : aiAnimMesh , aiMesh
  • mNumAllocated : aiMaterial
  • mNumAnimations : aiScene
  • mNumAnimMeshes : aiMesh
  • mNumBones : aiMesh
  • mNumCameras : aiScene
  • mNumChannels : aiAnimation
  • mNumChildren : aiNode
  • mNumFaces : aiMesh
  • mNumIndices : aiFace
  • mNumKeys : aiMeshAnim
  • mNumLights : aiScene
  • mNumMaterials : aiScene
  • mNumMeshChannels : aiAnimation
  • mNumMeshes : aiScene , aiNode
  • mNumPositionKeys : aiNodeAnim
  • mNumProperties : aiMaterial
  • mNumRotationKeys : aiNodeAnim
  • mNumScalingKeys : aiNodeAnim
  • mNumTextures : aiScene
  • mNumUVComponents : aiMesh
  • mNumVertices : aiAnimMesh , aiMesh
  • mNumWeights : aiBone
  • mOffsetMatrix : aiBone
  • mParent : aiNode
  • mPosition : aiLight , aiCamera
  • mPositionKeys : aiNodeAnim
  • mPostState : aiNodeAnim
  • mPreState : aiNodeAnim
  • mPrimitiveTypes : aiMesh
  • mPrivate : aiScene
  • mProperties : aiMaterial
  • mRootNode : aiScene
  • mRotation : aiUVTransform
  • mRotationKeys : aiNodeAnim
  • mScaling : aiUVTransform
  • mScalingKeys : aiNodeAnim
  • mTangents : aiMesh , aiAnimMesh
  • mTextureCoords : aiMesh , aiAnimMesh
  • mTextures : aiScene
  • mTicksPerSecond : aiAnimation
  • mTime : aiQuatKey , aiVectorKey , aiMeshKey
  • mTransformation : aiNode
  • mTranslation : aiUVTransform
  • mType : aiLight
  • mUp : aiCamera
  • mValue : aiMeshKey , aiQuatKey , aiVectorKey
  • mVertexId : aiVertexWeight
  • mVertices : aiAnimMesh , aiMesh
  • mWeight : aiVertexWeight
  • mWeights : aiBone
  • mWidth : aiTexture

- n -

  • name : aiExportDataBlob
  • next : aiExportDataBlob

- o -

  • OpenProc : aiFileIO

- p -

  • pcData : aiTexture
  • pimpl : Assimp::Exporter , Assimp::Importer
  • pos : aiRay
  • progress : Assimp::BaseImporter

- r -

  • r : aiColor4t< TReal > , aiTexel , aiColor3D
  • ReadProc : aiFile

- s -

  • SeekProc : aiFile
  • sentinel : aiPropertyStore
  • size : aiExportDataBlob

- t -

  • TellProc : aiFile

- u -

  • user : aiLogStream
  • UserData : aiFile , aiFileIO

- w -

  • w : aiQuaterniont< TReal >
  • WriteProc : aiFile

- x -

  • x : aiQuaterniont< TReal > , aiVector3t< TReal > , aiVector2t< TReal >

- y -

  • y : aiQuaterniont< TReal > , aiVector3t< TReal > , aiVector2t< TReal >

- z -

  • z : aiQuaterniont< TReal > , aiVector3t< TReal >


Assimp: File Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • c
  • m
  • o
  • p
Here is a list of all file members with links to the files they belong to:

- m -

  • MAX_LOG_MESSAGE_LENGTH : Logger.hpp
  • MAXLEN : types.h


Assimp: File Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • c
  • m
  • o
  • p
Here is a list of all file members with links to the files they belong to:

- o -

  • operator*() : color4.inl , vector2.inl , vector3.inl , vector2.inl , vector3.inl , color4.inl , vector2.inl , vector3.inl
  • operator+() : vector3.inl , color4.inl , vector2.inl
  • operator-() : color4.inl , vector2.inl , vector3.inl
  • operator/() : vector2.inl , color4.inl , vector3.inl , vector2.inl , color4.inl , vector3.inl
  • operator^() : vector3.inl


Assimp: File Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • c
  • m
  • o
  • p
Here is a list of all file members with links to the files they belong to:

- a -

  • ai_assert : ai_assert.h
  • AI_COLOR4D_INL_INC : color4.inl
  • AI_CONFIG_FAVOUR_SPEED : config.h
  • AI_CONFIG_GLOB_MEASURE_TIME : config.h
  • AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION : config.h
  • AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL : config.h
  • AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS : config.h
  • AI_CONFIG_IMPORT_GLOBAL_KEYFRAME : config.h
  • AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION : config.h
  • AI_CONFIG_IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS : config.h
  • AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS : config.h
  • AI_CONFIG_IMPORT_IRR_ANIM_FPS : config.h
  • AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY : config.h
  • AI_CONFIG_IMPORT_LWS_ANIM_END : config.h
  • AI_CONFIG_IMPORT_LWS_ANIM_START : config.h
  • AI_CONFIG_IMPORT_MD2_KEYFRAME : config.h
  • AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART : config.h
  • AI_CONFIG_IMPORT_MD3_KEYFRAME : config.h
  • AI_CONFIG_IMPORT_MD3_SHADER_SRC : config.h
  • AI_CONFIG_IMPORT_MD3_SKIN_NAME : config.h
  • AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD : config.h
  • AI_CONFIG_IMPORT_MDC_KEYFRAME : config.h
  • AI_CONFIG_IMPORT_MDL_COLORMAP : config.h
  • AI_CONFIG_IMPORT_MDL_KEYFRAME : config.h
  • AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE : config.h
  • AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME : config.h
  • AI_CONFIG_IMPORT_SMD_KEYFRAME : config.h
  • AI_CONFIG_IMPORT_TER_MAKE_UVS : config.h
  • AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS : config.h
  • AI_CONFIG_IMPORT_UNREAL_KEYFRAME : config.h
  • AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE : config.h
  • AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX : config.h
  • AI_CONFIG_PP_DB_ALL_OR_NONE : config.h
  • AI_CONFIG_PP_DB_THRESHOLD : config.h
  • AI_CONFIG_PP_FD_REMOVE : config.h
  • AI_CONFIG_PP_FID_ANIM_ACCURACY : config.h
  • AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE : config.h
  • AI_CONFIG_PP_ICL_PTCACHE_SIZE : config.h
  • AI_CONFIG_PP_LBW_MAX_WEIGHTS : config.h
  • AI_CONFIG_PP_OG_EXCLUDE_LIST : config.h
  • AI_CONFIG_PP_PTV_KEEP_HIERARCHY : config.h
  • AI_CONFIG_PP_PTV_NORMALIZE : config.h
  • AI_CONFIG_PP_RRM_EXCLUDE_LIST : config.h
  • AI_CONFIG_PP_RVC_FLAGS : config.h
  • AI_CONFIG_PP_SBBC_MAX_BONES : config.h
  • AI_CONFIG_PP_SBP_REMOVE : config.h
  • AI_CONFIG_PP_SLM_TRIANGLE_LIMIT : config.h
  • AI_CONFIG_PP_SLM_VERTEX_LIMIT : config.h
  • AI_CONFIG_PP_TUV_EVALUATE : config.h
  • AI_DEBONE_THRESHOLD : config.h
  • AI_DEFAULT_MATERIAL_NAME : material.h
  • AI_DEG_TO_RAD : defs.h
  • AI_FALSE : cimport.h
  • AI_FORCE_INLINE : defs.h
  • AI_LMW_MAX_WEIGHTS : config.h
  • AI_MAKE_EMBEDDED_TEXNAME : texture.h
  • AI_MAKE_MAGIC : BaseImporter.h
  • AI_MATERIAL_INL_INC : material.inl
  • AI_MATH_HALF_PI : defs.h
  • AI_MATH_HALF_PI_F : defs.h
  • AI_MATH_PI : defs.h
  • AI_MATH_PI_F : defs.h
  • AI_MATH_TWO_PI : defs.h
  • AI_MATH_TWO_PI_F : defs.h
  • AI_MATKEY_BLEND_FUNC : material.h
  • AI_MATKEY_BUMPSCALING : material.h
  • AI_MATKEY_COLOR_AMBIENT : material.h
  • AI_MATKEY_COLOR_DIFFUSE : material.h
  • AI_MATKEY_COLOR_EMISSIVE : material.h
  • AI_MATKEY_COLOR_REFLECTIVE : material.h
  • AI_MATKEY_COLOR_SPECULAR : material.h
  • AI_MATKEY_COLOR_TRANSPARENT : material.h
  • AI_MATKEY_ENABLE_WIREFRAME : material.h
  • AI_MATKEY_GLOBAL_BACKGROUND_IMAGE : material.h
  • AI_MATKEY_MAPPING : material.h
  • AI_MATKEY_MAPPINGMODE_U : material.h
  • AI_MATKEY_MAPPINGMODE_V : material.h
  • AI_MATKEY_NAME : material.h
  • AI_MATKEY_OPACITY : material.h
  • AI_MATKEY_REFLECTIVITY : material.h
  • AI_MATKEY_REFRACTI : material.h
  • AI_MATKEY_SHADING_MODEL : material.h
  • AI_MATKEY_SHININESS : material.h
  • AI_MATKEY_SHININESS_STRENGTH : material.h
  • AI_MATKEY_TEXBLEND : material.h
  • AI_MATKEY_TEXFLAGS : material.h
  • AI_MATKEY_TEXMAP_AXIS : material.h
  • AI_MATKEY_TEXOP : material.h
  • AI_MATKEY_TEXTURE : material.h
  • AI_MATKEY_TWOSIDED : material.h
  • AI_MATKEY_UVTRANSFORM : material.h
  • AI_MATKEY_UVWSRC : material.h
  • AI_MATRIX3x3_INL_INC : matrix3x3.inl
  • AI_MATRIX4x4_INL_INC : matrix4x4.inl
  • AI_MAX_BONE_WEIGHTS : mesh.h
  • AI_MAX_FACE_INDICES : mesh.h
  • AI_MAX_FACES : mesh.h
  • AI_MAX_NUMBER_OF_COLOR_SETS : mesh.h
  • AI_MAX_NUMBER_OF_TEXTURECOORDS : mesh.h
  • AI_MAX_VERTICES : mesh.h
  • AI_PRIMITIVE_TYPE_FOR_N_INDICES : mesh.h
  • AI_PROPERTY_WAS_NOT_EXISTING : Importer.hpp
  • AI_PUSHPACK_IS_DEFINED : pushpack1.h
  • AI_QUATERNION_INL_INC : quaternion.inl
  • AI_RAD_TO_DEG : defs.h
  • AI_SBBC_DEFAULT_MAX_BONES : config.h
  • AI_SLM_DEFAULT_MAX_TRIANGLES : config.h
  • AI_SLM_DEFAULT_MAX_VERTICES : config.h
  • AI_TEXTURE_TYPE_MAX : material.h
  • AI_TRUE : cimport.h
  • AI_UVTRAFO_ALL : config.h
  • AI_UVTRAFO_ROTATION : config.h
  • AI_UVTRAFO_SCALING : config.h
  • AI_UVTRAFO_TRANSLATION : config.h
  • AI_VECTOR2D_INL_INC : vector2.inl
  • AI_VECTOR3D_INL_INC : vector3.inl
  • AI_WONT_RETURN : defs.h
  • aiAnimBehaviour : anim.h
  • aiAnimBehaviour_CONSTANT : anim.h
  • aiAnimBehaviour_DEFAULT : anim.h
  • aiAnimBehaviour_LINEAR : anim.h
  • aiAnimBehaviour_REPEAT : anim.h
  • aiApplyPostProcessing() : cimport.h
  • aiAttachLogStream() : cimport.h
  • aiBlendMode : material.h
  • aiBlendMode_Additive : material.h
  • aiBlendMode_Default : material.h
  • aiBool : cimport.h
  • aiColor4D : color4.h
  • aiComponent : config.h
  • aiComponent_ANIMATIONS : config.h
  • aiComponent_BONEWEIGHTS : config.h
  • aiComponent_CAMERAS : config.h
  • aiComponent_COLORS : config.h
  • aiComponent_COLORSn : config.h
  • aiComponent_LIGHTS : config.h
  • aiComponent_MATERIALS : config.h
  • aiComponent_MESHES : config.h
  • aiComponent_NORMALS : config.h
  • aiComponent_TANGENTS_AND_BITANGENTS : config.h
  • aiComponent_TEXCOORDS : config.h
  • aiComponent_TEXCOORDSn : config.h
  • aiComponent_TEXTURES : config.h
  • aiCopyScene() : cexport.h
  • aiCreatePropertyStore() : cimport.h
  • aiCreateQuaternionFromMatrix() : cimport.h
  • aiDecomposeMatrix() : cimport.h
  • aiDetachAllLogStreams() : cimport.h
  • aiDetachLogStream() : cimport.h
  • aiEnableVerboseLogging() : cimport.h
  • aiExportScene() : cexport.h
  • aiExportSceneEx() : cexport.h
  • aiExportSceneToBlob() : cexport.h
  • aiFileCloseProc : cfileio.h
  • aiFileFlushProc : cfileio.h
  • aiFileOpenProc : cfileio.h
  • aiFileReadProc : cfileio.h
  • aiFileSeek : cfileio.h
  • aiFileTellProc : cfileio.h
  • aiFileWriteProc : cfileio.h
  • aiGetCompileFlags() : version.h
  • aiGetErrorString() : cimport.h
  • aiGetExportFormatCount() : cexport.h
  • aiGetExportFormatDescription() : cexport.h
  • aiGetExtensionList() : cimport.h
  • aiGetLegalString() : version.h
  • aiGetMemoryRequirements() : cimport.h
  • aiGetPredefinedLogStream() : cimport.h
  • aiGetVersionMajor() : version.h
  • aiGetVersionMinor() : version.h
  • aiGetVersionRevision() : version.h
  • aiIdentityMatrix3() : cimport.h
  • aiIdentityMatrix4() : cimport.h
  • aiImporterFlags : importerdesc.h
  • aiImporterFlags_Experimental : importerdesc.h
  • aiImporterFlags_LimitedSupport : importerdesc.h
  • aiImporterFlags_SupportBinaryFlavour : importerdesc.h
  • aiImporterFlags_SupportCompressedFlavour : importerdesc.h
  • aiImporterFlags_SupportTextFlavour : importerdesc.h
  • aiImportFile() : cimport.h
  • aiImportFileEx() : cimport.h
  • aiImportFileExWithProperties() : cimport.h
  • aiImportFileFromMemory() : cimport.h
  • aiImportFileFromMemoryWithProperties() : cimport.h
  • aiIsExtensionSupported() : cimport.h
  • aiLightSource_DIRECTIONAL : light.h
  • aiLightSource_POINT : light.h
  • aiLightSource_SPOT : light.h
  • aiLightSource_UNDEFINED : light.h
  • aiLightSourceType : light.h
  • aiLogStreamCallback : cimport.h
  • aiMatrix3x3 : matrix3x3.h
  • aiMatrix4x4 : matrix4x4.h
  • aiMultiplyMatrix3() : cimport.h
  • aiMultiplyMatrix4() : cimport.h
  • aiPostProcessSteps : postprocess.h
  • aiPrimitiveType : mesh.h
  • aiPrimitiveType_LINE : mesh.h
  • aiPrimitiveType_POINT : mesh.h
  • aiPrimitiveType_POLYGON : mesh.h
  • aiPrimitiveType_TRIANGLE : mesh.h
  • aiProcess_CalcTangentSpace : postprocess.h
  • aiProcess_ConvertToLeftHanded : postprocess.h
  • aiProcess_Debone : postprocess.h
  • aiProcess_FindDegenerates : postprocess.h
  • aiProcess_FindInstances : postprocess.h
  • aiProcess_FindInvalidData : postprocess.h
  • aiProcess_FixInfacingNormals : postprocess.h
  • aiProcess_FlipUVs : postprocess.h
  • aiProcess_FlipWindingOrder : postprocess.h
  • aiProcess_GenNormals : postprocess.h
  • aiProcess_GenSmoothNormals : postprocess.h
  • aiProcess_GenUVCoords : postprocess.h
  • aiProcess_ImproveCacheLocality : postprocess.h
  • aiProcess_JoinIdenticalVertices : postprocess.h
  • aiProcess_LimitBoneWeights : postprocess.h
  • aiProcess_MakeLeftHanded : postprocess.h
  • aiProcess_OptimizeGraph : postprocess.h
  • aiProcess_OptimizeMeshes : postprocess.h
  • aiProcess_PreTransformVertices : postprocess.h
  • aiProcess_RemoveComponent : postprocess.h
  • aiProcess_RemoveRedundantMaterials : postprocess.h
  • aiProcess_SortByPType : postprocess.h
  • aiProcess_SplitByBoneCount : postprocess.h
  • aiProcess_SplitLargeMeshes : postprocess.h
  • aiProcess_TransformUVCoords : postprocess.h
  • aiProcess_Triangulate : postprocess.h
  • aiProcess_ValidateDataStructure : postprocess.h
  • aiProcessPreset_TargetRealtime_Fast : postprocess.h
  • aiProcessPreset_TargetRealtime_MaxQuality : postprocess.h
  • aiProcessPreset_TargetRealtime_Quality : postprocess.h
  • aiQuaternion : quaternion.h
  • aiReleaseExportBlob() : cexport.h
  • aiReleaseImport() : cimport.h
  • aiReleasePropertyStore() : cimport.h
  • aiSetImportPropertyFloat() : cimport.h
  • aiSetImportPropertyInteger() : cimport.h
  • aiSetImportPropertyString() : cimport.h
  • aiShadingMode : material.h
  • aiShadingMode_Blinn : material.h
  • aiShadingMode_CookTorrance : material.h
  • aiShadingMode_Flat : material.h
  • aiShadingMode_Fresnel : material.h
  • aiShadingMode_Gouraud : material.h
  • aiShadingMode_Minnaert : material.h
  • aiShadingMode_NoShading : material.h
  • aiShadingMode_OrenNayar : material.h
  • aiShadingMode_Phong : material.h
  • aiShadingMode_Toon : material.h
  • aiTextureFlags : material.h
  • aiTextureFlags_IgnoreAlpha : material.h
  • aiTextureFlags_Invert : material.h
  • aiTextureFlags_UseAlpha : material.h
  • aiTextureMapMode : material.h
  • aiTextureMapMode_Clamp : material.h
  • aiTextureMapMode_Decal : material.h
  • aiTextureMapMode_Mirror : material.h
  • aiTextureMapMode_Wrap : material.h
  • aiTextureMapping : material.h
  • aiTextureMapping_BOX : material.h
  • aiTextureMapping_CYLINDER : material.h
  • aiTextureMapping_OTHER : material.h
  • aiTextureMapping_PLANE : material.h
  • aiTextureMapping_SPHERE : material.h
  • aiTextureMapping_UV : material.h
  • aiTextureOp : material.h
  • aiTextureOp_Add : material.h
  • aiTextureOp_Divide : material.h
  • aiTextureOp_Multiply : material.h
  • aiTextureOp_SignedAdd : material.h
  • aiTextureOp_SmoothAdd : material.h
  • aiTextureOp_Subtract : material.h
  • aiTextureType : material.h
  • aiTextureType_AMBIENT : material.h
  • aiTextureType_DIFFUSE : material.h
  • aiTextureType_DISPLACEMENT : material.h
  • aiTextureType_EMISSIVE : material.h
  • aiTextureType_HEIGHT : material.h
  • aiTextureType_LIGHTMAP : material.h
  • aiTextureType_NONE : material.h
  • aiTextureType_NORMALS : material.h
  • aiTextureType_OPACITY : material.h
  • aiTextureType_REFLECTION : material.h
  • aiTextureType_SHININESS : material.h
  • aiTextureType_SPECULAR : material.h
  • aiTextureType_UNKNOWN : material.h
  • aiTransformVecByMatrix3() : cimport.h
  • aiTransformVecByMatrix4() : cimport.h
  • aiTransposeMatrix3() : cimport.h
  • aiTransposeMatrix4() : cimport.h
  • aiUserData : cfileio.h
  • aiVector2D : vector2.h
  • aiVector3D : vector3.h
  • ASSIMP_API : defs.h
  • ASSIMP_API_WINONLY : defs.h
  • ASSIMP_BUILD_NEED_Z_INFLATE : defs.h
  • ASSIMP_BUILD_SINGLETHREADED : defs.h
  • ASSIMP_CFLAGS_DEBUG : version.h
  • ASSIMP_CFLAGS_NOBOOST : version.h
  • ASSIMP_CFLAGS_SHARED : version.h
  • ASSIMP_CFLAGS_SINGLETHREADED : version.h
  • ASSIMP_CFLAGS_STLPORT : version.h
  • ASSIMP_DEFAULT_LOG_NAME : DefaultLogger.hpp


Assimp: File Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • c
  • m
  • o
  • p
Here is a list of all file members with links to the files they belong to:

- c -

  • C_ENUM : defs.h
  • C_STRUCT : defs.h


Assimp: File Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a
  • c
  • m
  • o
  • p
Here is a list of all file members with links to the files they belong to:

- p -

  • PACK_STRUCT : color4.h , material.h , matrix4x4.h , vector2.h , types.h , texture.h , vector3.h , matrix3x3.h
  • PP_ICL_PTCACHE_SIZE : config.h


Assimp: File Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • a
  • c
  • m
  • p

- a -

  • ai_assert : ai_assert.h
  • AI_COLOR4D_INL_INC : color4.inl
  • AI_CONFIG_FAVOUR_SPEED : config.h
  • AI_CONFIG_GLOB_MEASURE_TIME : config.h
  • AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION : config.h
  • AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL : config.h
  • AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS : config.h
  • AI_CONFIG_IMPORT_GLOBAL_KEYFRAME : config.h
  • AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION : config.h
  • AI_CONFIG_IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS : config.h
  • AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS : config.h
  • AI_CONFIG_IMPORT_IRR_ANIM_FPS : config.h
  • AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY : config.h
  • AI_CONFIG_IMPORT_LWS_ANIM_END : config.h
  • AI_CONFIG_IMPORT_LWS_ANIM_START : config.h
  • AI_CONFIG_IMPORT_MD2_KEYFRAME : config.h
  • AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART : config.h
  • AI_CONFIG_IMPORT_MD3_KEYFRAME : config.h
  • AI_CONFIG_IMPORT_MD3_SHADER_SRC : config.h
  • AI_CONFIG_IMPORT_MD3_SKIN_NAME : config.h
  • AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD : config.h
  • AI_CONFIG_IMPORT_MDC_KEYFRAME : config.h
  • AI_CONFIG_IMPORT_MDL_COLORMAP : config.h
  • AI_CONFIG_IMPORT_MDL_KEYFRAME : config.h
  • AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE : config.h
  • AI_CONFIG_IMPORT_OGRE_TEXTURETYPE_FROM_FILENAME : config.h
  • AI_CONFIG_IMPORT_SMD_KEYFRAME : config.h
  • AI_CONFIG_IMPORT_TER_MAKE_UVS : config.h
  • AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS : config.h
  • AI_CONFIG_IMPORT_UNREAL_KEYFRAME : config.h
  • AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE : config.h
  • AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX : config.h
  • AI_CONFIG_PP_DB_ALL_OR_NONE : config.h
  • AI_CONFIG_PP_DB_THRESHOLD : config.h
  • AI_CONFIG_PP_FD_REMOVE : config.h
  • AI_CONFIG_PP_FID_ANIM_ACCURACY : config.h
  • AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE : config.h
  • AI_CONFIG_PP_ICL_PTCACHE_SIZE : config.h
  • AI_CONFIG_PP_LBW_MAX_WEIGHTS : config.h
  • AI_CONFIG_PP_OG_EXCLUDE_LIST : config.h
  • AI_CONFIG_PP_PTV_KEEP_HIERARCHY : config.h
  • AI_CONFIG_PP_PTV_NORMALIZE : config.h
  • AI_CONFIG_PP_RRM_EXCLUDE_LIST : config.h
  • AI_CONFIG_PP_RVC_FLAGS : config.h
  • AI_CONFIG_PP_SBBC_MAX_BONES : config.h
  • AI_CONFIG_PP_SBP_REMOVE : config.h
  • AI_CONFIG_PP_SLM_TRIANGLE_LIMIT : config.h
  • AI_CONFIG_PP_SLM_VERTEX_LIMIT : config.h
  • AI_CONFIG_PP_TUV_EVALUATE : config.h
  • AI_DEBONE_THRESHOLD : config.h
  • AI_DEFAULT_MATERIAL_NAME : material.h
  • AI_DEG_TO_RAD : defs.h
  • AI_FALSE : cimport.h
  • AI_FORCE_INLINE : defs.h
  • AI_LMW_MAX_WEIGHTS : config.h
  • AI_MAKE_EMBEDDED_TEXNAME : texture.h
  • AI_MAKE_MAGIC : BaseImporter.h
  • AI_MATERIAL_INL_INC : material.inl
  • AI_MATH_HALF_PI : defs.h
  • AI_MATH_HALF_PI_F : defs.h
  • AI_MATH_PI : defs.h
  • AI_MATH_PI_F : defs.h
  • AI_MATH_TWO_PI : defs.h
  • AI_MATH_TWO_PI_F : defs.h
  • AI_MATKEY_BLEND_FUNC : material.h
  • AI_MATKEY_BUMPSCALING : material.h
  • AI_MATKEY_COLOR_AMBIENT : material.h
  • AI_MATKEY_COLOR_DIFFUSE : material.h
  • AI_MATKEY_COLOR_EMISSIVE : material.h
  • AI_MATKEY_COLOR_REFLECTIVE : material.h
  • AI_MATKEY_COLOR_SPECULAR : material.h
  • AI_MATKEY_COLOR_TRANSPARENT : material.h
  • AI_MATKEY_ENABLE_WIREFRAME : material.h
  • AI_MATKEY_GLOBAL_BACKGROUND_IMAGE : material.h
  • AI_MATKEY_MAPPING : material.h
  • AI_MATKEY_MAPPINGMODE_U : material.h
  • AI_MATKEY_MAPPINGMODE_V : material.h
  • AI_MATKEY_NAME : material.h
  • AI_MATKEY_OPACITY : material.h
  • AI_MATKEY_REFLECTIVITY : material.h
  • AI_MATKEY_REFRACTI : material.h
  • AI_MATKEY_SHADING_MODEL : material.h
  • AI_MATKEY_SHININESS : material.h
  • AI_MATKEY_SHININESS_STRENGTH : material.h
  • AI_MATKEY_TEXBLEND : material.h
  • AI_MATKEY_TEXFLAGS : material.h
  • AI_MATKEY_TEXMAP_AXIS : material.h
  • AI_MATKEY_TEXOP : material.h
  • AI_MATKEY_TEXTURE : material.h
  • AI_MATKEY_TWOSIDED : material.h
  • AI_MATKEY_UVTRANSFORM : material.h
  • AI_MATKEY_UVWSRC : material.h
  • AI_MATRIX3x3_INL_INC : matrix3x3.inl
  • AI_MATRIX4x4_INL_INC : matrix4x4.inl
  • AI_MAX_BONE_WEIGHTS : mesh.h
  • AI_MAX_FACE_INDICES : mesh.h
  • AI_MAX_FACES : mesh.h
  • AI_MAX_NUMBER_OF_COLOR_SETS : mesh.h
  • AI_MAX_NUMBER_OF_TEXTURECOORDS : mesh.h
  • AI_MAX_VERTICES : mesh.h
  • AI_PRIMITIVE_TYPE_FOR_N_INDICES : mesh.h
  • AI_PROPERTY_WAS_NOT_EXISTING : Importer.hpp
  • AI_PUSHPACK_IS_DEFINED : pushpack1.h
  • AI_QUATERNION_INL_INC : quaternion.inl
  • AI_RAD_TO_DEG : defs.h
  • AI_SBBC_DEFAULT_MAX_BONES : config.h
  • AI_SLM_DEFAULT_MAX_TRIANGLES : config.h
  • AI_SLM_DEFAULT_MAX_VERTICES : config.h
  • AI_TEXTURE_TYPE_MAX : material.h
  • AI_TRUE : cimport.h
  • AI_UVTRAFO_ALL : config.h
  • AI_UVTRAFO_ROTATION : config.h
  • AI_UVTRAFO_SCALING : config.h
  • AI_UVTRAFO_TRANSLATION : config.h
  • AI_VECTOR2D_INL_INC : vector2.inl
  • AI_VECTOR3D_INL_INC : vector3.inl
  • AI_WONT_RETURN : defs.h
  • aiComponent_COLORSn : config.h
  • aiComponent_TEXCOORDSn : config.h
  • aiProcess_ConvertToLeftHanded : postprocess.h
  • aiProcessPreset_TargetRealtime_Fast : postprocess.h
  • aiProcessPreset_TargetRealtime_MaxQuality : postprocess.h
  • aiProcessPreset_TargetRealtime_Quality : postprocess.h
  • ASSIMP_API : defs.h
  • ASSIMP_API_WINONLY : defs.h
  • ASSIMP_BUILD_NEED_Z_INFLATE : defs.h
  • ASSIMP_BUILD_SINGLETHREADED : defs.h
  • ASSIMP_CFLAGS_DEBUG : version.h
  • ASSIMP_CFLAGS_NOBOOST : version.h
  • ASSIMP_CFLAGS_SHARED : version.h
  • ASSIMP_CFLAGS_SINGLETHREADED : version.h
  • ASSIMP_CFLAGS_STLPORT : version.h
  • ASSIMP_DEFAULT_LOG_NAME : DefaultLogger.hpp

- c -

  • C_ENUM : defs.h
  • C_STRUCT : defs.h

- m -

  • MAX_LOG_MESSAGE_LENGTH : Logger.hpp

- p -

  • PP_ICL_PTCACHE_SIZE : config.h


Assimp: File Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • aiAnimBehaviour : anim.h
  • aiBlendMode : material.h
  • aiComponent : config.h
  • aiImporterFlags : importerdesc.h
  • aiLightSourceType : light.h
  • aiPostProcessSteps : postprocess.h
  • aiPrimitiveType : mesh.h
  • aiShadingMode : material.h
  • aiTextureFlags : material.h
  • aiTextureMapMode : material.h
  • aiTextureMapping : material.h
  • aiTextureOp : material.h
  • aiTextureType : material.h


Assimp: File Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • _
  • a

- _ -

  • _aiAnimBehaviour_Force32Bit : anim.h
  • _aiComponent_Force32Bit : config.h
  • _aiLightSource_Force32Bit : light.h
  • _aiPrimitiveType_Force32Bit : mesh.h

- a -

  • aiAnimBehaviour_CONSTANT : anim.h
  • aiAnimBehaviour_DEFAULT : anim.h
  • aiAnimBehaviour_LINEAR : anim.h
  • aiAnimBehaviour_REPEAT : anim.h
  • aiBlendMode_Additive : material.h
  • aiBlendMode_Default : material.h
  • aiComponent_ANIMATIONS : config.h
  • aiComponent_BONEWEIGHTS : config.h
  • aiComponent_CAMERAS : config.h
  • aiComponent_COLORS : config.h
  • aiComponent_LIGHTS : config.h
  • aiComponent_MATERIALS : config.h
  • aiComponent_MESHES : config.h
  • aiComponent_NORMALS : config.h
  • aiComponent_TANGENTS_AND_BITANGENTS : config.h
  • aiComponent_TEXCOORDS : config.h
  • aiComponent_TEXTURES : config.h
  • aiImporterFlags_Experimental : importerdesc.h
  • aiImporterFlags_LimitedSupport : importerdesc.h
  • aiImporterFlags_SupportBinaryFlavour : importerdesc.h
  • aiImporterFlags_SupportCompressedFlavour : importerdesc.h
  • aiImporterFlags_SupportTextFlavour : importerdesc.h
  • aiLightSource_DIRECTIONAL : light.h
  • aiLightSource_POINT : light.h
  • aiLightSource_SPOT : light.h
  • aiLightSource_UNDEFINED : light.h
  • aiPrimitiveType_LINE : mesh.h
  • aiPrimitiveType_POINT : mesh.h
  • aiPrimitiveType_POLYGON : mesh.h
  • aiPrimitiveType_TRIANGLE : mesh.h
  • aiProcess_CalcTangentSpace : postprocess.h
  • aiProcess_Debone : postprocess.h
  • aiProcess_FindDegenerates : postprocess.h
  • aiProcess_FindInstances : postprocess.h
  • aiProcess_FindInvalidData : postprocess.h
  • aiProcess_FixInfacingNormals : postprocess.h
  • aiProcess_FlipUVs : postprocess.h
  • aiProcess_FlipWindingOrder : postprocess.h
  • aiProcess_GenNormals : postprocess.h
  • aiProcess_GenSmoothNormals : postprocess.h
  • aiProcess_GenUVCoords : postprocess.h
  • aiProcess_ImproveCacheLocality : postprocess.h
  • aiProcess_JoinIdenticalVertices : postprocess.h
  • aiProcess_LimitBoneWeights : postprocess.h
  • aiProcess_MakeLeftHanded : postprocess.h
  • aiProcess_OptimizeGraph : postprocess.h
  • aiProcess_OptimizeMeshes : postprocess.h
  • aiProcess_PreTransformVertices : postprocess.h
  • aiProcess_RemoveComponent : postprocess.h
  • aiProcess_RemoveRedundantMaterials : postprocess.h
  • aiProcess_SortByPType : postprocess.h
  • aiProcess_SplitByBoneCount : postprocess.h
  • aiProcess_SplitLargeMeshes : postprocess.h
  • aiProcess_TransformUVCoords : postprocess.h
  • aiProcess_Triangulate : postprocess.h
  • aiProcess_ValidateDataStructure : postprocess.h
  • aiShadingMode_Blinn : material.h
  • aiShadingMode_CookTorrance : material.h
  • aiShadingMode_Flat : material.h
  • aiShadingMode_Fresnel : material.h
  • aiShadingMode_Gouraud : material.h
  • aiShadingMode_Minnaert : material.h
  • aiShadingMode_NoShading : material.h
  • aiShadingMode_OrenNayar : material.h
  • aiShadingMode_Phong : material.h
  • aiShadingMode_Toon : material.h
  • aiTextureFlags_IgnoreAlpha : material.h
  • aiTextureFlags_Invert : material.h
  • aiTextureFlags_UseAlpha : material.h
  • aiTextureMapMode_Clamp : material.h
  • aiTextureMapMode_Decal : material.h
  • aiTextureMapMode_Mirror : material.h
  • aiTextureMapMode_Wrap : material.h
  • aiTextureMapping_BOX : material.h
  • aiTextureMapping_CYLINDER : material.h
  • aiTextureMapping_OTHER : material.h
  • aiTextureMapping_PLANE : material.h
  • aiTextureMapping_SPHERE : material.h
  • aiTextureMapping_UV : material.h
  • aiTextureOp_Add : material.h
  • aiTextureOp_Divide : material.h
  • aiTextureOp_Multiply : material.h
  • aiTextureOp_SignedAdd : material.h
  • aiTextureOp_SmoothAdd : material.h
  • aiTextureOp_Subtract : material.h
  • aiTextureType_AMBIENT : material.h
  • aiTextureType_DIFFUSE : material.h
  • aiTextureType_DISPLACEMENT : material.h
  • aiTextureType_EMISSIVE : material.h
  • aiTextureType_HEIGHT : material.h
  • aiTextureType_LIGHTMAP : material.h
  • aiTextureType_NONE : material.h
  • aiTextureType_NORMALS : material.h
  • aiTextureType_OPACITY : material.h
  • aiTextureType_REFLECTION : material.h
  • aiTextureType_SHININESS : material.h
  • aiTextureType_SPECULAR : material.h
  • aiTextureType_UNKNOWN : material.h


Assimp: File Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • a
  • o

- a -

  • aiApplyPostProcessing() : cimport.h
  • aiAttachLogStream() : cimport.h
  • aiCopyScene() : cexport.h
  • aiCreatePropertyStore() : cimport.h
  • aiCreateQuaternionFromMatrix() : cimport.h
  • aiDecomposeMatrix() : cimport.h
  • aiDetachAllLogStreams() : cimport.h
  • aiDetachLogStream() : cimport.h
  • aiEnableVerboseLogging() : cimport.h
  • aiExportScene() : cexport.h
  • aiExportSceneEx() : cexport.h
  • aiExportSceneToBlob() : cexport.h
  • aiGetCompileFlags() : version.h
  • aiGetErrorString() : cimport.h
  • aiGetExportFormatCount() : cexport.h
  • aiGetExportFormatDescription() : cexport.h
  • aiGetExtensionList() : cimport.h
  • aiGetLegalString() : version.h
  • aiGetMemoryRequirements() : cimport.h
  • aiGetPredefinedLogStream() : cimport.h
  • aiGetVersionMajor() : version.h
  • aiGetVersionMinor() : version.h
  • aiGetVersionRevision() : version.h
  • aiIdentityMatrix3() : cimport.h
  • aiIdentityMatrix4() : cimport.h
  • aiImportFile() : cimport.h
  • aiImportFileEx() : cimport.h
  • aiImportFileExWithProperties() : cimport.h
  • aiImportFileFromMemory() : cimport.h
  • aiImportFileFromMemoryWithProperties() : cimport.h
  • aiIsExtensionSupported() : cimport.h
  • aiMultiplyMatrix3() : cimport.h
  • aiMultiplyMatrix4() : cimport.h
  • aiReleaseExportBlob() : cexport.h
  • aiReleaseImport() : cimport.h
  • aiReleasePropertyStore() : cimport.h
  • aiSetImportPropertyFloat() : cimport.h
  • aiSetImportPropertyInteger() : cimport.h
  • aiSetImportPropertyString() : cimport.h
  • aiTransformVecByMatrix3() : cimport.h
  • aiTransformVecByMatrix4() : cimport.h
  • aiTransposeMatrix3() : cimport.h
  • aiTransposeMatrix4() : cimport.h

- o -

  • operator*() : color4.inl , vector2.inl , vector3.inl , vector2.inl , vector3.inl , color4.inl , vector2.inl , vector3.inl
  • operator+() : vector3.inl , color4.inl , vector2.inl
  • operator-() : color4.inl , vector2.inl , vector3.inl
  • operator/() : vector2.inl , color4.inl , vector3.inl , vector2.inl , color4.inl , vector3.inl
  • operator^() : vector3.inl


Assimp: File Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • aiBool : cimport.h
  • aiColor4D : color4.h
  • aiFileCloseProc : cfileio.h
  • aiFileFlushProc : cfileio.h
  • aiFileOpenProc : cfileio.h
  • aiFileReadProc : cfileio.h
  • aiFileSeek : cfileio.h
  • aiFileTellProc : cfileio.h
  • aiFileWriteProc : cfileio.h
  • aiLogStreamCallback : cimport.h
  • aiMatrix3x3 : matrix3x3.h
  • aiMatrix4x4 : matrix4x4.h
  • aiQuaternion : quaternion.h
  • aiUserData : cfileio.h
  • aiVector2D : vector2.h
  • aiVector3D : vector3.h


Assimp: File Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • Defines
  • MAXLEN : types.h
  • PACK_STRUCT : color4.h , vector3.h , vector2.h , types.h , texture.h , matrix4x4.h , matrix3x3.h , material.h


Assimp: Member List

  • Assimp
  • Exporter
  • ExportFormatEntry
Assimp::Exporter::ExportFormatEntry Member List
This is the complete list of members for Assimp::Exporter::ExportFormatEntry, including all inherited members.
ExportFormatEntry(const char *pId, const char *pDesc, const char *pExtension, fpExportFunc pFunction, unsigned int pEnforcePP=0u) | Assimp::Exporter::ExportFormatEntry | [inline]
ExportFormatEntry() | Assimp::Exporter::ExportFormatEntry | [inline]
mDescription | Assimp::Exporter::ExportFormatEntry |
mEnforcePP | Assimp::Exporter::ExportFormatEntry |
mExportFunction | Assimp::Exporter::ExportFormatEntry |


Assimp: Member List

  • Assimp
  • Interpolator
Assimp::Interpolator< T > Member List
This is the complete list of members for Assimp::Interpolator< T >, including all inherited members.
operator()(T &out, const T &a, const T &b, float d) const Assimp::Interpolator< T > [inline]


Assimp: Member List

  • Assimp
  • ScopeGuard
Assimp::ScopeGuard< T > Member List
This is the complete list of members for Assimp::ScopeGuard< T >, including all inherited members.
dismiss() | Assimp::ScopeGuard< T > | [inline]
operator T *() | Assimp::ScopeGuard< T > | [inline]
operator->() | Assimp::ScopeGuard< T > | [inline]
ScopeGuard(T *obj) | Assimp::ScopeGuard< T > | [inline]
~ScopeGuard() | Assimp::ScopeGuard< T > | [inline]


Assimp: Member List

aiAnimMesh Member List
This is the complete list of members for aiAnimMesh, including all inherited members.
aiAnimMesh() | aiAnimMesh | [inline]
HasNormals() const | aiAnimMesh | [inline]
HasPositions() const | aiAnimMesh | [inline]
HasTangentsAndBitangents() const | aiAnimMesh | [inline]
HasTextureCoords(unsigned int pIndex) const | aiAnimMesh | [inline]
HasVertexColors(unsigned int pIndex) const | aiAnimMesh | [inline]
mBitangents | aiAnimMesh |
mColors | aiAnimMesh |
mNormals | aiAnimMesh |
mNumVertices | aiAnimMesh |
mTangents | aiAnimMesh |
mTextureCoords | aiAnimMesh |
mVertices | aiAnimMesh |
~aiAnimMesh() | aiAnimMesh | [inline]


Assimp: Member List

aiAnimation Member List
This is the complete list of members for aiAnimation, including all inherited members.
aiAnimation() | aiAnimation | [inline]
mChannels | aiAnimation |
mDuration | aiAnimation |
mMeshChannels | aiAnimation |
mName | aiAnimation |
mNumChannels | aiAnimation |
mNumMeshChannels | aiAnimation |
mTicksPerSecond | aiAnimation |
~aiAnimation() | aiAnimation | [inline]


Assimp: Member List

aiBone Member List
This is the complete list of members for aiBone, including all inherited members.
aiBone() | aiBone | [inline]
aiBone(const aiBone &other) | aiBone | [inline]
mName | aiBone |
mNumWeights | aiBone |
mOffsetMatrix | aiBone |
mWeights | aiBone |
~aiBone() | aiBone | [inline]


Assimp: Member List

aiCamera Member List
This is the complete list of members for aiCamera, including all inherited members.
aiCamera() | aiCamera | [inline]
GetCameraMatrix(aiMatrix4x4 &out) const | aiCamera | [inline]
mAspect | aiCamera |
mClipPlaneFar | aiCamera |
mClipPlaneNear | aiCamera |
mHorizontalFOV | aiCamera |
mLookAt | aiCamera |
mName | aiCamera |
mPosition | aiCamera |
mUp | aiCamera |


Assimp: Member List

aiColor3D Member List
This is the complete list of members for aiColor3D, including all inherited members.
aiColor3D() | aiColor3D | [inline]
aiColor3D(float _r, float _g, float _b) | aiColor3D | [inline]
aiColor3D(float _r) | aiColor3D | [inline]
aiColor3D(const aiColor3D &o) | aiColor3D | [inline]
b | aiColor3D |
g | aiColor3D |
IsBlack() const | aiColor3D | [inline]
operator!=(const aiColor3D &other) const | aiColor3D | [inline]
operator*(const aiColor3D &c) const | aiColor3D | [inline]
operator*(float f) const | aiColor3D | [inline]
operator+(const aiColor3D &c) const | aiColor3D | [inline]
operator-(const aiColor3D &c) const | aiColor3D | [inline]
operator==(const aiColor3D &other) const | aiColor3D | [inline]
operator[](unsigned int i) const | aiColor3D | [inline]
operator[](unsigned int i) | aiColor3D | [inline]
r | aiColor3D |


Assimp: Member List

aiExportDataBlob Member List
This is the complete list of members for aiExportDataBlob, including all inherited members.
aiExportDataBlob() | aiExportDataBlob | [inline]
data | aiExportDataBlob |
name | aiExportDataBlob |
next | aiExportDataBlob |
size | aiExportDataBlob |
~aiExportDataBlob() | aiExportDataBlob | [inline]


Assimp: Member List

aiExportFormatDesc Member List
This is the complete list of members for aiExportFormatDesc, including all inherited members.
description | aiExportFormatDesc
fileExtension | aiExportFormatDesc
id | aiExportFormatDesc


Assimp: Member List

aiFace Member List
This is the complete list of members for aiFace, including all inherited members.
aiFace() | aiFace | [inline]
aiFace(const aiFace &o) | aiFace | [inline]
mIndices | aiFace |
mNumIndices | aiFace |
operator!=(const aiFace &o) const | aiFace | [inline]
operator=(const aiFace &o) | aiFace | [inline]
operator==(const aiFace &o) const | aiFace | [inline]
~aiFace() | aiFace | [inline]


Assimp: Member List

aiFile Member List
This is the complete list of members for aiFile, including all inherited members.
FileSizeProc | aiFile
FlushProc | aiFile
ReadProc | aiFile
SeekProc | aiFile
TellProc | aiFile
UserData | aiFile
WriteProc | aiFile


Assimp: Member List

aiFileIO Member List
This is the complete list of members for aiFileIO, including all inherited members.
CloseProc | aiFileIO
OpenProc | aiFileIO
UserData | aiFileIO


Assimp: Member List

aiImporterDesc Member List
This is the complete list of members for aiImporterDesc, including all inherited members.
mAuthor | aiImporterDesc
mComments | aiImporterDesc
mFileExtensions | aiImporterDesc
mFlags | aiImporterDesc
mMaintainer | aiImporterDesc
mMaxMajor | aiImporterDesc
mMaxMinor | aiImporterDesc
mMinMajor | aiImporterDesc
mMinMinor | aiImporterDesc
mName | aiImporterDesc


Assimp: Member List

aiLight Member List
This is the complete list of members for aiLight, including all inherited members.
aiLight() | aiLight | [inline]
mAngleInnerCone | aiLight |
mAngleOuterCone | aiLight |
mAttenuationConstant | aiLight |
mAttenuationLinear | aiLight |
mAttenuationQuadratic | aiLight |
mColorAmbient | aiLight |
mColorDiffuse | aiLight |
mColorSpecular | aiLight |
mDirection | aiLight |
mName | aiLight |
mPosition | aiLight |
mType | aiLight |


Assimp: Member List

aiLogStream Member List
This is the complete list of members for aiLogStream, including all inherited members.
callback | aiLogStream
user | aiLogStream


Assimp: Member List

aiMaterial Member List
This is the complete list of members for aiMaterial, including all inherited members.
AddBinaryProperty(const void *pInput, unsigned int pSizeInBytes, const char *pKey, unsigned int type, unsigned int index, aiPropertyTypeInfo pType) | aiMaterial |
AddProperty(const aiString *pInput, const char *pKey, unsigned int type=0, unsigned int index=0) | aiMaterial |
AddProperty(const TYPE *pInput, unsigned int pNumValues, const char *pKey, unsigned int type=0, unsigned int index=0) | aiMaterial |
aiMaterial() | aiMaterial |
Clear() | aiMaterial |
CopyPropertyList(aiMaterial *pcDest, const aiMaterial *pcSrc) | aiMaterial | [static]
Get(const char *pKey, unsigned int type, unsigned int idx, Type *pOut, unsigned int *pMax) const | aiMaterial |
Get(const char *pKey, unsigned int type, unsigned int idx, Type &pOut) const | aiMaterial |
GetTexture(aiTextureType type, unsigned int index, aiString *path, aiTextureMapping *mapping=NULL, unsigned int *uvindex=NULL, float *blend=NULL, aiTextureOp *op=NULL, aiTextureMapMode *mapmode=NULL) const | aiMaterial |
GetTextureCount(aiTextureType type) const | aiMaterial |
mNumAllocated | aiMaterial |
mNumProperties | aiMaterial |
mProperties | aiMaterial |
RemoveProperty(const char *pKey, unsigned int type=0, unsigned int index=0) | aiMaterial |
~aiMaterial() | aiMaterial |


Assimp: Member List

aiMesh Member List
This is the complete list of members for aiMesh, including all inherited members.
aiMesh() | aiMesh | [inline]
GetNumColorChannels() const | aiMesh | [inline]
GetNumUVChannels() const | aiMesh | [inline]
HasBones() const | aiMesh | [inline]
HasFaces() const | aiMesh | [inline]
HasNormals() const | aiMesh | [inline]
HasPositions() const | aiMesh | [inline]
HasTangentsAndBitangents() const | aiMesh | [inline]
HasTextureCoords(unsigned int pIndex) const | aiMesh | [inline]
HasVertexColors(unsigned int pIndex) const | aiMesh | [inline]
mAnimMeshes | aiMesh |
mBitangents | aiMesh |
mBones | aiMesh |
mColors | aiMesh |
mFaces | aiMesh |
mMaterialIndex | aiMesh |
mName | aiMesh |
mNormals | aiMesh |
mNumAnimMeshes | aiMesh |
mNumBones | aiMesh |
mNumFaces | aiMesh |
mNumUVComponents | aiMesh |
mNumVertices | aiMesh |
mPrimitiveTypes | aiMesh |
mTangents | aiMesh |
mTextureCoords | aiMesh |
mVertices | aiMesh |
~aiMesh() | aiMesh | [inline]


Assimp: Member List

aiMeshAnim Member List
This is the complete list of members for aiMeshAnim, including all inherited members.
aiMeshAnim() | aiMeshAnim | [inline]
mKeys | aiMeshAnim |
mName | aiMeshAnim |
mNumKeys | aiMeshAnim |
~aiMeshAnim() | aiMeshAnim | [inline]


Assimp: Member List

aiMeshKey Member List
This is the complete list of members for aiMeshKey, including all inherited members.
aiMeshKey() | aiMeshKey | [inline]
aiMeshKey(double time, const unsigned int value) | aiMeshKey | [inline]
elem_type typedef | aiMeshKey |
mTime | aiMeshKey |
mValue | aiMeshKey |
operator!=(const aiMeshKey &o) const | aiMeshKey | [inline]
operator<(const aiMeshKey &o) const | aiMeshKey | [inline]
operator==(const aiMeshKey &o) const | aiMeshKey | [inline]
operator>(const aiMeshKey &o) const | aiMeshKey | [inline]


Assimp: Member List

aiNode Member List
This is the complete list of members for aiNode, including all inherited members.
aiNode() | aiNode | [inline]
aiNode(const std::string &name) | aiNode | [inline]
FindNode(const aiString &name) | aiNode | [inline]
FindNode(const char *name) | aiNode | [inline]
mChildren | aiNode |
mMeshes | aiNode |
mName | aiNode |
mNumChildren | aiNode |
mNumMeshes | aiNode |
mParent | aiNode |
mTransformation | aiNode |
~aiNode() | aiNode | [inline]


Assimp: Member List

aiNodeAnim Member List
This is the complete list of members for aiNodeAnim, including all inherited members.
aiNodeAnim() | aiNodeAnim | [inline]
mNodeName | aiNodeAnim |
mNumPositionKeys | aiNodeAnim |
mNumRotationKeys | aiNodeAnim |
mNumScalingKeys | aiNodeAnim |
mPositionKeys | aiNodeAnim |
mPostState | aiNodeAnim |
mPreState | aiNodeAnim |
mRotationKeys | aiNodeAnim |
mScalingKeys | aiNodeAnim |
~aiNodeAnim() | aiNodeAnim | [inline]


Assimp: Member List

aiPlane Member List
This is the complete list of members for aiPlane, including all inherited members.
a | aiPlane |
aiPlane() | aiPlane | [inline]
aiPlane(float _a, float _b, float _c, float _d) | aiPlane | [inline]
aiPlane(const aiPlane &o) | aiPlane | [inline]
b | aiPlane |
c | aiPlane |
d | aiPlane |


Assimp: Member List

aiPropertyStore Member List
This is the complete list of members for aiPropertyStore, including all inherited members.
sentinel aiPropertyStore


Assimp: Member List

aiQuatKey Member List
This is the complete list of members for aiQuatKey, including all inherited members.
aiQuatKey() | aiQuatKey | [inline]
aiQuatKey(double time, const aiQuaternion &value) | aiQuatKey | [inline]
elem_type typedef | aiQuatKey |
mTime | aiQuatKey |
mValue | aiQuatKey |
operator!=(const aiQuatKey &o) const | aiQuatKey | [inline]
operator<(const aiQuatKey &o) const | aiQuatKey | [inline]
operator==(const aiQuatKey &o) const | aiQuatKey | [inline]
operator>(const aiQuatKey &o) const | aiQuatKey | [inline]


Assimp: Member List

aiRay Member List
This is the complete list of members for aiRay, including all inherited members.
aiRay() | aiRay | [inline]
aiRay(const aiVector3D &_pos, const aiVector3D &_dir) | aiRay | [inline]
aiRay(const aiRay &o) | aiRay | [inline]
dir | aiRay |
pos | aiRay |


Assimp: Member List

aiScene Member List
This is the complete list of members for aiScene, including all inherited members.
aiScene() | aiScene |
HasAnimations() const | aiScene | [inline]
HasCameras() const | aiScene | [inline]
HasLights() const | aiScene | [inline]
HasMaterials() const | aiScene | [inline]
HasMeshes() const | aiScene | [inline]
HasTextures() const | aiScene | [inline]
mAnimations | aiScene |
mCameras | aiScene |
mFlags | aiScene |
mLights | aiScene |
mMaterials | aiScene |
mMeshes | aiScene |
mNumAnimations | aiScene |
mNumCameras | aiScene |
mNumLights | aiScene |
mNumMaterials | aiScene |
mNumMeshes | aiScene |
mNumTextures | aiScene |
mPrivate | aiScene |
mRootNode | aiScene |
mTextures | aiScene |
~aiScene() | aiScene |


Assimp: Member List

aiString Member List
This is the complete list of members for aiString, including all inherited members.
aiString() | aiString | [inline]
aiString(const aiString &rOther) | aiString | [inline]
aiString(const std::string &pString) | aiString | [inline, explicit]
Append(const char *app) | aiString | [inline]
C_Str() const | aiString | [inline]
Clear() | aiString | [inline]
data | aiString |
length | aiString |
operator!=(const aiString &other) const | aiString | [inline]
operator=(const char *sz) | aiString | [inline]
operator=(const std::string &pString) | aiString | [inline]
operator==(const aiString &other) const | aiString | [inline]
Set(const std::string &pString) | aiString | [inline]
Set(const char *sz) | aiString | [inline]


Assimp: Member List

aiTexel Member List
This is the complete list of members for aiTexel, including all inherited members.
a | aiTexel |
b | aiTexel |
g | aiTexel |
operator aiColor4D() const | aiTexel | [inline]
operator!=(const aiTexel &other) const | aiTexel | [inline]
operator==(const aiTexel &other) const | aiTexel | [inline]
r | aiTexel |


Assimp: Member List

aiTexture Member List
This is the complete list of members for aiTexture, including all inherited members.
achFormatHint | aiTexture |
aiTexture() | aiTexture | [inline]
CheckFormat(const char *s) const | aiTexture | [inline]
mHeight | aiTexture |
mWidth | aiTexture |
pcData | aiTexture |
~aiTexture() | aiTexture | [inline]


Assimp: Member List

aiUVTransform Member List
This is the complete list of members for aiUVTransform, including all inherited members.
aiUVTransform() | aiUVTransform | [inline]
mRotation | aiUVTransform |
mScaling | aiUVTransform |
mTranslation | aiUVTransform |


Assimp: Member List

aiVectorKey Member List
This is the complete list of members for aiVectorKey, including all inherited members.
aiVectorKey() | aiVectorKey | [inline]
aiVectorKey(double time, const aiVector3D &value) | aiVectorKey | [inline]
elem_type typedef | aiVectorKey |
mTime | aiVectorKey |
mValue | aiVectorKey |
operator!=(const aiVectorKey &o) const | aiVectorKey | [inline]
operator<(const aiVectorKey &o) const | aiVectorKey | [inline]
operator==(const aiVectorKey &o) const | aiVectorKey | [inline]
operator>(const aiVectorKey &o) const | aiVectorKey | [inline]


Assimp: Member List

aiVertexWeight Member List
This is the complete list of members for aiVertexWeight, including all inherited members.
aiVertexWeight() | aiVertexWeight | [inline]
aiVertexWeight(unsigned int pID, float pWeight) | aiVertexWeight | [inline]
mVertexId | aiVertexWeight |
mWeight | aiVertexWeight |